Java 类org.bson.types.Decimal128 实例源码

private static Decimal128Pojo insert(MongoDatabase db) {
    MongoCollection<Decimal128Pojo> coll = db.getCollection(COLL_NAME,
            Decimal128Pojo.class);
    Decimal128Pojo pojo = new Decimal128Pojo();
    pojo.setScalar(new Decimal128(2001));
    pojo.setArray(new Decimal128[] { new Decimal128(2002), new Decimal128(2003),
            new Decimal128(2004) });
    pojo.setArray2(new Decimal128[][] { { new Decimal128(2005) },
            { new Decimal128(2006), new Decimal128(2007) } });
    pojo.setList(Arrays.asList(new Decimal128(2008), new Decimal128(2009)));

    Set<Decimal128> set = new HashSet<>();
    set.add(new Decimal128(2012));
    pojo.setSet(set);

    Map<String, Decimal128> map = new HashMap<>();
    map.put("one", new Decimal128(2011));
    map.put("two", new Decimal128(2012));
    map.put("three", new Decimal128(2013));
    map.put("null", null);
    pojo.setMap(map);

    coll.insertOne(pojo);
    return pojo;
}

@SuppressWarnings("unchecked")
@Test
public void testWithDocument() {
    MongoDatabase db = connect();
    Decimal128Pojo pojo = insert(db);

    MongoCollection<Document> coll = db.getCollection(COLL_NAME);
    Document doc = coll.find().first();
    assertThat(doc).hasSize(7);
    assertThat(doc.get("_id")).isEqualTo(pojo.getId());
    assertThat(doc.get("scalar")).isEqualTo(new Decimal128(2001));
    assertThat((List<Decimal128>) doc.get("array")).containsExactly(
            new Decimal128(2002), new Decimal128(2003), new Decimal128(2004));
    assertThat((List<List<Decimal128>>) doc.get("array2")).containsExactly(
            Arrays.asList(new Decimal128(2005)),
            Arrays.asList(new Decimal128(2006), new Decimal128(2007)));
    assertThat((List<Decimal128>) doc.get("list"))
            .containsExactly(new Decimal128(2008), new Decimal128(2009));
    assertThat((List<Decimal128>) doc.get("set"))
            .containsExactly(new Decimal128(2012));
    assertThat((Map<String, Decimal128>) doc.get("map")).containsOnly(
            MapEntry.entry("one", new Decimal128(2011)),
            MapEntry.entry("two", new Decimal128(2012)),
            MapEntry.entry("three", new Decimal128(2013)),
            MapEntry.entry("null", null));
}

@Test
public void read() throws Exception {
  BsonDocument doc = new BsonDocument();
  doc.put("int", new BsonDecimal128(Decimal128.parse(Integer.toString(Integer.MAX_VALUE))));
  doc.put("long", new BsonDecimal128(new Decimal128(Long.MAX_VALUE)));
  doc.put("double", new BsonDecimal128(Decimal128.parse("12.111")));

  JsonReader reader =  Jsons.asGsonReader(doc);

  reader.beginObject();
  check(reader.nextName()).is("int");
  check(reader.peek()).is(JsonToken.NUMBER);
  check(reader.nextInt()).is(Integer.MAX_VALUE);

  check(reader.nextName()).is("long");
  check(reader.peek()).is(JsonToken.NUMBER);
  check(reader.nextLong()).is(Long.MAX_VALUE);

  check(reader.nextName()).is("double");
  check(reader.peek()).is(JsonToken.NUMBER);
  check(reader.nextDouble()).is(12.111D);

  reader.endObject();

  reader.close();
}

@Override
public void write(JsonWriter out, Decimal128 value) throws IOException {
  if (value == null) {
    out.nullValue();
  } else if (out instanceof BsonWriter) {
    ((BsonWriter) out).value(value);
  } else {
    out.value(value.toString());
  }
}

@Override
public Decimal128 read(JsonReader in) throws IOException {
  if (in.peek() == JsonToken.NULL) {
    in.nextNull();
    return null;
  }
  if (in instanceof BsonReader) {
    return ((BsonReader) in).nextDecimal();
  }
  return Decimal128.parse(in.nextString());
}

@Override
public Object decode(final Class<?> targetClass, final Object value, final MappedField optionalExtraInfo) {
    if (value == null) {
        return null;
    }

    if (value instanceof BigDecimal) {
        return value;
    }

    if (value instanceof Decimal128) {
        return ((Decimal128) value).bigDecimalValue();
    }

    if (value instanceof BigInteger) {
        return new BigDecimal(((BigInteger) value));
    }

    if (value instanceof Double) {
        return new BigDecimal(((Double) value));
    }

    if (value instanceof Long) {
        return new BigDecimal(((Long) value));
    }

    if (value instanceof Number) {
        return new BigDecimal(((Number) value).doubleValue());
    }

    return new BigDecimal(value.toString());
}

@Override
public Object encode(final Object value, final MappedField optionalExtraInfo) {
    if (value instanceof BigDecimal) {
        return new Decimal128((BigDecimal) value);
    }
    return super.encode(value, optionalExtraInfo);
}

@Override
public void accept(ObjectMapper mapper) {
    SimpleModule module = new SimpleModule();

    addSerializer(module, BsonBoolean.class, (value, gen) -> {
        gen.writeBoolean(value.getValue());
    });

    addSerializer(module, BsonDateTime.class, (value, gen) -> {
        if (Config.USE_TIMESTAMPS) {
            gen.writeString(DataConverterRegistry.convert(String.class, new Date(value.getValue())));
        } else {
            gen.writeNumber(value.getValue());
        }
    });

    addSerializer(module, BsonDouble.class, (value, gen) -> {
        gen.writeNumber(value.getValue());
    });

    addSerializer(module, BsonInt32.class, (value, gen) -> {
        gen.writeNumber(value.getValue());
    });

    addSerializer(module, BsonInt64.class, (value, gen) -> {
        gen.writeNumber(value.getValue());
    });

    addSerializer(module, BsonNull.class, (value, gen) -> {
        gen.writeNull();
    });

    addSerializer(module, BsonRegularExpression.class, (value, gen) -> {
        gen.writeString(value.getPattern());
    });

    addSerializer(module, BsonString.class, (value, gen) -> {
        gen.writeString(value.getValue());
    });

    addSerializer(module, BsonTimestamp.class, (value, gen) -> {
        if (Config.USE_TIMESTAMPS) {
            gen.writeString(DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L)));
        } else {
            gen.writeNumber(value.getTime());
        }
    });

    addSerializer(module, BsonUndefined.class, (value, gen) -> {
        gen.writeNull();
    });

    addSerializer(module, Binary.class, (value, gen) -> {
        gen.writeString(BASE64.encode(value.getData()));
    });

    addSerializer(module, Code.class, (value, gen) -> {
        gen.writeString(value.getCode());
    });

    addSerializer(module, Decimal128.class, (value, gen) -> {
        gen.writeNumber(value.bigDecimalValue());
    });

    addSerializer(module, ObjectId.class, (value, gen) -> {
        gen.writeString(value.toHexString());
    });

    addSerializer(module, Symbol.class, (value, gen) -> {
        gen.writeString(value.getSymbol());
    });

    mapper.registerModule(module);
}

@Override
public void accept(ExtensibleRepresenter representer) {

    addSerializer(representer, BsonBoolean.class, (value) -> {
        return Boolean.toString(value.getValue());
    });

    addSerializer(representer, BsonDateTime.class, (value) -> {
        if (Config.USE_TIMESTAMPS) {
            return DataConverterRegistry.convert(String.class, new Date(value.getValue()));
        }
        return Long.toString(value.getValue());
    });

    addSerializer(representer, BsonDouble.class, (value) -> {
        return Double.toString(value.getValue());
    });

    addSerializer(representer, BsonInt32.class, (value) -> {
        return Integer.toString(value.getValue());
    });

    addSerializer(representer, BsonInt64.class, (value) -> {
        return Long.toString(value.getValue());
    });

    addSerializer(representer, BsonNull.class, (value) -> {
        return null;
    });

    addSerializer(representer, BsonRegularExpression.class, (value) -> {
        return value.getPattern();
    });

    addSerializer(representer, BsonString.class, (value) -> {
        return value.getValue();
    });

    addSerializer(representer, BsonTimestamp.class, (value) -> {
        if (Config.USE_TIMESTAMPS) {
            return DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L));
        }
        return Integer.toString(value.getTime());
    });

    addSerializer(representer, BsonUndefined.class, (value) -> {
        return null;
    });

    addSerializer(representer, Binary.class, (value) -> {
        return BASE64.encode(value.getData());
    });

    addSerializer(representer, Code.class, (value) -> {
        return value.getCode();
    });

    addSerializer(representer, Decimal128.class, (value) -> {
        return value.bigDecimalValue().toPlainString();
    });

    addSerializer(representer, ObjectId.class, (value) -> {
        return value.toHexString();
    });

    addSerializer(representer, Symbol.class, (value) -> {
        return value.getSymbol();
    });

}

@Override
public void accept(MapperBuilder builder) {

    addSerializer(builder, BsonBoolean.class, Boolean.class, (value) -> {
        return value.getValue();
    });

    if (Config.USE_TIMESTAMPS) {
        addSerializer(builder, BsonDateTime.class, String.class, (value) -> {
            return DataConverterRegistry.convert(String.class, new Date(value.getValue()));
        });
    } else {
        addSerializer(builder, BsonDateTime.class, Long.class, (value) -> {
            return value.getValue();
        });
    }

    addSerializer(builder, BsonDouble.class, Double.class, (value) -> {
        return value.getValue();
    });

    addSerializer(builder, BsonInt32.class, Integer.class, (value) -> {
        return value.getValue();
    });

    addSerializer(builder, BsonInt64.class, Long.class, (value) -> {
        return value.getValue();
    });

    addSerializer(builder, BsonNull.class, Object.class, (value) -> {

        // Johnzon fails from null values
        return "null";
    });

    addSerializer(builder, BsonRegularExpression.class, String.class, (value) -> {
        return value.getPattern();
    });

    addSerializer(builder, BsonString.class, String.class, (value) -> {
        return value.getValue();
    });

    if (Config.USE_TIMESTAMPS) {
        addSerializer(builder, BsonTimestamp.class, String.class, (value) -> {
            return DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L));
        });
    } else {
        addSerializer(builder, BsonTimestamp.class, Integer.class, (value) -> {
            return value.getTime();
        });
    }

    addSerializer(builder, BsonUndefined.class, String.class, (value) -> {

        // Johnzon fails from null values
        return "null";
    });

    addSerializer(builder, Binary.class, String.class, (value) -> {
        return BASE64.encode(value.getData());
    });

    addSerializer(builder, Code.class, String.class, (value) -> {
        return value.getCode();
    });

    addSerializer(builder, Decimal128.class, BigDecimal.class, (value) -> {
        return value.bigDecimalValue();
    });

    addSerializer(builder, ObjectId.class, String.class, (value) -> {
        return value.toHexString();
    });

    addSerializer(builder, Symbol.class, String.class, (value) -> {
        return value.getSymbol();
    });

}

@Override
public void accept(GensonBuilder builder) {

    addSerializer(builder, BsonBoolean.class, (value, writer, ctx) -> {
        writer.writeBoolean(value.getValue());
    });

    addSerializer(builder, BsonDateTime.class, (value, writer, ctx) -> {
        if (Config.USE_TIMESTAMPS) {
            writer.writeString(DataConverterRegistry.convert(String.class, new Date(value.getValue())));
        } else {
            writer.writeNumber(value.getValue());
        }
    });

    addSerializer(builder, BsonDouble.class, (value, writer, ctx) -> {
        writer.writeNumber(value.getValue());
    });

    addSerializer(builder, BsonInt32.class, (value, writer, ctx) -> {
        writer.writeNumber(value.getValue());
    });

    addSerializer(builder, BsonInt64.class, (value, writer, ctx) -> {
        writer.writeNumber(value.getValue());
    });

    addSerializer(builder, BsonNull.class, (value, writer, ctx) -> {
        writer.writeNull();
    });

    addSerializer(builder, BsonRegularExpression.class, (value, writer, ctx) -> {
        writer.writeString(value.getPattern());
    });

    addSerializer(builder, BsonString.class, (value, writer, ctx) -> {
        writer.writeString(value.getValue());
    });

    addSerializer(builder, BsonTimestamp.class, (value, writer, ctx) -> {
        if (Config.USE_TIMESTAMPS) {
            writer.writeString(DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L)));
        } else {
            writer.writeNumber(value.getTime());
        }
    });

    addSerializer(builder, BsonUndefined.class, (value, writer, ctx) -> {
        writer.writeNull();
    });

    addSerializer(builder, Binary.class, (value, writer, ctx) -> {
        writer.writeString(BASE64.encode(value.getData()));
    });

    addSerializer(builder, Code.class, (value, writer, ctx) -> {
        writer.writeString(value.getCode());
    });

    addSerializer(builder, Decimal128.class, (value, writer, ctx) -> {
        writer.writeNumber(value.bigDecimalValue());
    });

    addSerializer(builder, ObjectId.class, (value, writer, ctx) -> {
        writer.writeString(value.toHexString());
    });

    addSerializer(builder, Symbol.class, (value, writer, ctx) -> {
        writer.writeString(value.getSymbol());
    });

}

@Override
public void accept(DslJson<Object> dslJson) {

    dslJson.registerWriter(BsonBoolean.class, (writer, value) -> {
        BoolConverter.serialize(value.getValue(), writer);
    });

    dslJson.registerWriter(BsonDateTime.class, (writer, value) -> {
        if (Config.USE_TIMESTAMPS) {
            StringConverter.serialize(DataConverterRegistry.convert(String.class, new Date(value.getValue())),
                    writer);
        } else {
            NumberConverter.serialize(value.getValue(), writer);
        }
    });

    dslJson.registerWriter(BsonDouble.class, (writer, value) -> {
        NumberConverter.serialize(value.getValue(), writer);
    });

    dslJson.registerWriter(BsonInt32.class, (writer, value) -> {
        NumberConverter.serialize(value.getValue(), writer);
    });

    dslJson.registerWriter(BsonInt64.class, (writer, value) -> {
        NumberConverter.serialize(value.getValue(), writer);
    });

    dslJson.registerWriter(BsonNull.class, (writer, value) -> {
        writer.writeNull();
    });

    dslJson.registerWriter(BsonRegularExpression.class, (writer, value) -> {
        StringConverter.serializeNullable(value.getPattern(), writer);
    });

    dslJson.registerWriter(BsonString.class, (writer, value) -> {
        StringConverter.serializeNullable(value.getValue(), writer);
    });

    dslJson.registerWriter(BsonTimestamp.class, (writer, value) -> {
        if (Config.USE_TIMESTAMPS) {
            StringConverter.serialize(
                    DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L)), writer);
        } else {
            NumberConverter.serialize(value.getTime(), writer);
        }
    });

    dslJson.registerWriter(BsonUndefined.class, (writer, value) -> {
        writer.writeNull();
    });

    dslJson.registerWriter(Binary.class, (writer, value) -> {
        StringConverter.serialize(BASE64.encode(value.getData()), writer);
    });

    dslJson.registerWriter(Code.class, (writer, value) -> {
        StringConverter.serializeNullable(value.getCode(), writer);
    });

    dslJson.registerWriter(Decimal128.class, (writer, value) -> {
        NumberConverter.serialize(value.bigDecimalValue(), writer);
    });

    dslJson.registerWriter(ObjectId.class, (writer, value) -> {
        StringConverter.serialize(value.toHexString(), writer);
    });

    dslJson.registerWriter(Symbol.class, (writer, value) -> {
        StringConverter.serializeNullable(value.getSymbol(), writer);
    });

}

@Override
public void accept(MessagePack mapper) {

    addSerializer(mapper, BsonBoolean.class, (packer, value) -> {
        packer.write(value.getValue());
    });

    addSerializer(mapper, BsonDateTime.class, (packer, value) -> {
        packer.write(value.getValue());
    });

    addSerializer(mapper, BsonDouble.class, (packer, value) -> {
        packer.write(value.getValue());
    });

    addSerializer(mapper, BsonInt32.class, (packer, value) -> {
        packer.write(value.getValue());
    });

    addSerializer(mapper, BsonInt64.class, (packer, value) -> {
        packer.write(value.getValue());
    });

    addSerializer(mapper, BsonNull.class, (packer, value) -> {
        packer.writeNil();
    });

    addSerializer(mapper, BsonRegularExpression.class, (packer, value) -> {
        packer.write(value.getPattern());
    });

    addSerializer(mapper, BsonString.class, (packer, value) -> {
        packer.write(value.getValue());
    });

    addSerializer(mapper, BsonTimestamp.class, (packer, value) -> {
        packer.write(value.getTime() * 1000L);
    });

    addSerializer(mapper, BsonUndefined.class, (packer, value) -> {
        packer.writeNil();
    });

    addSerializer(mapper, Binary.class, (packer, value) -> {
        packer.write(BASE64.encode(value.getData()));
    });

    addSerializer(mapper, Code.class, (packer, value) -> {
        packer.write(value.getCode());
    });

    addSerializer(mapper, Decimal128.class, (packer, value) -> {
        packer.write(value.bigDecimalValue());
    });

    addSerializer(mapper, ObjectId.class, (packer, value) -> {
        packer.write(value.toHexString());
    });

    addSerializer(mapper, Symbol.class, (packer, value) -> {
        packer.write(value.getSymbol());
    });

}

@Override
public void accept(SerializeConfig config) {

    addSerializer(config, BsonBoolean.class, (value, serializer) -> {
        serializer.write(value.getValue());
    });

    addSerializer(config, BsonDateTime.class, (value, serializer) -> {
        if (Config.USE_TIMESTAMPS) {
            serializer.write(DataConverterRegistry.convert(String.class, new Date(value.getValue())));
        } else {
            serializer.write(value.getValue());
        }
    });

    addSerializer(config, BsonDouble.class, (value, serializer) -> {
        serializer.write(value.getValue());
    });

    addSerializer(config, BsonInt32.class, (value, serializer) -> {
        serializer.write(value.getValue());
    });

    addSerializer(config, BsonInt64.class, (value, serializer) -> {
        serializer.write(value.getValue());
    });

    addSerializer(config, BsonNull.class, (value, serializer) -> {
        serializer.writeNull();
    });

    addSerializer(config, BsonRegularExpression.class, (value, serializer) -> {
        serializer.write(value.getPattern());
    });

    addSerializer(config, BsonString.class, (value, serializer) -> {
        serializer.write(value.getValue());
    });

    addSerializer(config, BsonTimestamp.class, (value, serializer) -> {
        if (Config.USE_TIMESTAMPS) {
            serializer.write(DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L)));
        } else {
            serializer.write(value.getTime());
        }
    });

    addSerializer(config, BsonUndefined.class, (value, serializer) -> {
        serializer.writeNull();
    });

    addSerializer(config, Binary.class, (value, serializer) -> {
        serializer.write(BASE64.encode(value.getData()));
    });

    addSerializer(config, Code.class, (value, serializer) -> {
        serializer.write(value.getCode());
    });

    addSerializer(config, Decimal128.class, (value, serializer) -> {
    serializer.write(value.bigDecimalValue());
    });

    addSerializer(config, ObjectId.class, (value, serializer) -> {
        serializer.write(value.toHexString());
    });

    addSerializer(config, Symbol.class, (value, serializer) -> {
        serializer.write(value.getSymbol());
    });

}

@Override
public void accept(JsonSerializer serializer) {

    addSerializer(serializer, BsonBoolean.class, (value, ctx) -> {
        ctx.write(Boolean.toString(value.getValue()));
    });

    addSerializer(serializer, BsonDateTime.class, (value, ctx) -> {
        if (Config.USE_TIMESTAMPS) {
            ctx.writeString(DataConverterRegistry.convert(String.class, new Date(value.getValue())));
        } else {
            ctx.writeNumber(value.getValue());
        }
    });

    addSerializer(serializer, BsonDouble.class, (value, ctx) -> {
        ctx.writeNumber(value.getValue());
    });

    addSerializer(serializer, BsonInt32.class, (value, ctx) -> {
        ctx.writeNumber(value.getValue());
    });

    addSerializer(serializer, BsonInt64.class, (value, ctx) -> {
        ctx.writeNumber(value.getValue());
    });

    addSerializer(serializer, BsonNull.class, (value, ctx) -> {
        ctx.write("null");
    });

    addSerializer(serializer, BsonRegularExpression.class, (value, ctx) -> {
        ctx.writeString(value.getPattern());
    });

    addSerializer(serializer, BsonString.class, (value, ctx) -> {
        ctx.writeString(value.getValue());
    });

    addSerializer(serializer, BsonTimestamp.class, (value, ctx) -> {
        if (Config.USE_TIMESTAMPS) {
            ctx.writeString(
                    DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L)));
        } else {
            ctx.writeNumber(value.getTime());
        }
    });

    addSerializer(serializer, BsonUndefined.class, (value, ctx) -> {
        ctx.write("null");
    });

    addSerializer(serializer, Binary.class, (value, ctx) -> {
        ctx.writeString(BASE64.encode(value.getData()));
    });

    addSerializer(serializer, Code.class, (value, ctx) -> {
        ctx.writeString(value.getCode());
    });

    addSerializer(serializer, Decimal128.class, (value, ctx) -> {
        ctx.writeNumber(value.bigDecimalValue());
    });

    addSerializer(serializer, ObjectId.class, (value, ctx) -> {
        ctx.writeString(value.toHexString());
    });

    addSerializer(serializer, Symbol.class, (value, ctx) -> {
        ctx.writeString(value.getSymbol());
    });
}

@Override
public void accept(TypeTransformerMap map) {

    addSerializer(map, BsonBoolean.class, (value, ctx) -> {
        ctx.write(Boolean.toString(value.getValue()));
    });

    addSerializer(map, BsonDateTime.class, (value, ctx) -> {
        if (Config.USE_TIMESTAMPS) {
            ctx.writeQuoted(DataConverterRegistry.convert(String.class, new Date(value.getValue())));
        } else {
            ctx.write(Long.toString(value.getValue()));
        }
    });

    addSerializer(map, BsonDouble.class, (value, ctx) -> {
        ctx.write(Double.toString(value.getValue()));
    });

    addSerializer(map, BsonInt32.class, (value, ctx) -> {
        ctx.write(Integer.toString(value.getValue()));
    });

    addSerializer(map, BsonInt64.class, (value, ctx) -> {
        ctx.write(Long.toString(value.getValue()));
    });

    addSerializer(map, BsonNull.class, (value, ctx) -> {
        ctx.write("null");
    });

    addSerializer(map, BsonRegularExpression.class, (value, ctx) -> {
        ctx.writeQuoted(value.getPattern());
    });

    addSerializer(map, BsonString.class, (value, ctx) -> {
        ctx.writeQuoted(value.getValue());
    });

    addSerializer(map, BsonTimestamp.class, (value, ctx) -> {
        if (Config.USE_TIMESTAMPS) {
            ctx.writeQuoted(DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L)));
        } else {
            ctx.write(Integer.toString(value.getTime()));
        }
    });

    addSerializer(map, BsonUndefined.class, (value, ctx) -> {
        ctx.write("null");
    });

    addSerializer(map, Binary.class, (value, ctx) -> {
        ctx.writeQuoted(BASE64.encode(value.getData()));
    });

    addSerializer(map, Code.class, (value, ctx) -> {
        ctx.writeQuoted(value.getCode());
    });

    addSerializer(map, Decimal128.class, (value, ctx) -> {
        ctx.write(value.bigDecimalValue().toPlainString());
    });

    addSerializer(map, ObjectId.class, (value, ctx) -> {
        ctx.writeQuoted(value.toHexString());
    });

    addSerializer(map, Symbol.class, (value, ctx) -> {
        ctx.writeQuoted(value.getSymbol());
    });

}

@Override
public void accept(HashMap<Class<?>, Function<Object, Object>> converters) {

    addSerializer(converters, BsonBoolean.class, (value) -> {
        return value.getValue();
    });

    addSerializer(converters, BsonDateTime.class, (value) -> {
        return new Date(value.getValue());
    });

    addSerializer(converters, BsonDouble.class, (value) -> {
        return value.getValue();
    });

    addSerializer(converters, BsonInt32.class, (value) -> {
        return value.getValue();
    });

    addSerializer(converters, BsonInt64.class, (value) -> {
        return value.getValue();
    });

    addSerializer(converters, BsonNull.class, (value) -> {
        return null;
    });

    addSerializer(converters, BsonRegularExpression.class, (value) -> {
        return value.getPattern();
    });

    addSerializer(converters, BsonString.class, (value) -> {
        return value.getValue();
    });

    addSerializer(converters, BsonTimestamp.class, (value) -> {
        return new Date(value.getTime() * 1000L);
    });

    addSerializer(converters, BsonUndefined.class, (value) -> {
        return null;
    });

    addSerializer(converters, Binary.class, (value) -> {
        return value.getData();
    });

    addSerializer(converters, Code.class, (value) -> {
        return value.getCode();
    });

    addSerializer(converters, Decimal128.class, (value) -> {
        return value.bigDecimalValue();
    });

    addSerializer(converters, ObjectId.class, (value) -> {
        return value.toHexString();
    });

    addSerializer(converters, Symbol.class, (value) -> {
        return value.getSymbol();
    });

}

@Override
public void accept(GsonBuilder builder) {

    addSerializer(builder, BsonBoolean.class, (value) -> {
        return new JsonPrimitive(value.getValue());
    });

    addSerializer(builder, BsonDateTime.class, (value) -> {
        if (Config.USE_TIMESTAMPS) {
            return new JsonPrimitive(DataConverterRegistry.convert(String.class, new Date(value.getValue())));
        } else {
            return new JsonPrimitive(value.getValue());
        }
    });

    addSerializer(builder, BsonDouble.class, (value) -> {
        return new JsonPrimitive(value.getValue());
    });

    addSerializer(builder, BsonInt32.class, (value) -> {
        return new JsonPrimitive(value.getValue());
    });

    addSerializer(builder, BsonInt64.class, (value) -> {
        return new JsonPrimitive(value.getValue());
    });

    addSerializer(builder, BsonNull.class, (value) -> {
        return JsonNull.INSTANCE;
    });

    addSerializer(builder, BsonRegularExpression.class, (value) -> {
        return new JsonPrimitive(value.getPattern());
    });

    addSerializer(builder, BsonString.class, (value) -> {
        return new JsonPrimitive(value.getValue());
    });

    addSerializer(builder, BsonTimestamp.class, (value) -> {
        if (Config.USE_TIMESTAMPS) {
            return new JsonPrimitive(
                    DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L)));
        } else {
            return new JsonPrimitive(value.getTime());
        }
    });

    addSerializer(builder, BsonUndefined.class, (value) -> {
        return JsonNull.INSTANCE;
    });

    addSerializer(builder, Binary.class, (value) -> {
        return new JsonPrimitive(BASE64.encode(value.getData()));
    });

    addSerializer(builder, Code.class, (value) -> {
        return new JsonPrimitive(value.getCode());
    });

    addSerializer(builder, Decimal128.class, (value) -> {
        return new JsonPrimitive(value.bigDecimalValue());
    });

    addSerializer(builder, ObjectId.class, (value) -> {
        return new JsonPrimitive(value.toHexString());
    });

    addSerializer(builder, Symbol.class, (value) -> {
        return new JsonPrimitive(value.getSymbol());
    });

}

@Override
public void accept(XStream mapper) {

    addSerializer(mapper, BsonBoolean.class, (value) -> {
        return Boolean.toString(value.getValue());
    });

    addSerializer(mapper, BsonDateTime.class, (value) -> {
        if (Config.USE_TIMESTAMPS) {
            return DataConverterRegistry.convert(String.class, new Date(value.getValue()));
        }
        return Long.toString(value.getValue());
    });

    addSerializer(mapper, BsonDouble.class, (value) -> {
        return Double.toString(value.getValue());
    });

    addSerializer(mapper, BsonInt32.class, (value) -> {
        return Integer.toString(value.getValue());
    });

    addSerializer(mapper, BsonInt64.class, (value) -> {
        return Long.toString(value.getValue());
    });

    addSerializer(mapper, BsonNull.class, (value) -> {
        return "null";
    });

    addSerializer(mapper, BsonRegularExpression.class, (value) -> {
        return value.getPattern();
    });

    addSerializer(mapper, BsonString.class, (value) -> {
        return value.getValue();
    });

    addSerializer(mapper, BsonTimestamp.class, (value) -> {
        if (Config.USE_TIMESTAMPS) {
            return DataConverterRegistry.convert(String.class, new Date(value.getTime() * 1000L));
        }
        return Integer.toString(value.getTime());
    });

    addSerializer(mapper, BsonUndefined.class, (value) -> {
        return "null";
    });

    addSerializer(mapper, Binary.class, (value) -> {
        return BASE64.encode(value.getData());
    });

    addSerializer(mapper, Code.class, (value) -> {
        return value.getCode();
    });

    addSerializer(mapper, Decimal128.class, (value) -> {
        return value.bigDecimalValue().toPlainString();
    });

    addSerializer(mapper, ObjectId.class, (value) -> {
        return value.toHexString();
    });

    addSerializer(mapper, Symbol.class, (value) -> {
        return value.getSymbol();
    });

}

@Override
public final void encode(final org.bson.BsonWriter writer, final BigDecimal value,
        final EncoderContext encoderContext) {
    writer.writeDecimal128(new Decimal128(value));
}

@Test
public void testMongoTypes() throws Exception {

    // JSON-Simple and JsonUtil aren't extendable APIs
    String writerClass = TreeWriterRegistry.getWriter(TreeWriterRegistry.JSON).getClass().toString();
    boolean unsupportedAPI = writerClass.contains("Simple") || writerClass.contains("JsonUtil");
    if (unsupportedAPI) {
        return;
    }

    Document doc = new Document();
    doc.put("BsonBoolean", new BsonBoolean(true));
    long time = System.currentTimeMillis();
    doc.put("BsonDateTime", new BsonDateTime(time));
    doc.put("BsonDouble", new BsonDouble(123.456));
    doc.put("BsonInt32", new BsonInt32(123));
    doc.put("BsonInt64", new BsonInt64(123456));
    doc.put("BsonNull", new BsonNull());
    doc.put("BsonRegularExpression", new BsonRegularExpression("abc"));
    doc.put("BsonString", new BsonString("abcdefgh"));
    doc.put("BsonTimestamp", new BsonTimestamp(12, 23));
    doc.put("BsonUndefined", new BsonUndefined());
    doc.put("Binary", new Binary("abcdefgh".getBytes()));
    doc.put("Code", new Code("var a = 5;"));
    doc.put("Decimal128", new Decimal128(123456789));
    ObjectId objectID = new ObjectId();
    doc.put("ObjectId", objectID);
    doc.put("Symbol", new Symbol("s"));

    Tree t = new Tree(doc, null);
    String json = t.toString();

    System.out.println("-------------------- BSON --------------------");
    System.out.println("Output of " + writerClass + " serializer (MongoDB types):");
    System.out.println(json);

    t = new Tree(json);

    assertTrue(t.get("BsonBoolean", false));

    Date date = t.get("BsonDateTime", new Date());
    assertEquals(time / 1000L, date.getTime() / 1000L);

    assertEquals(123.456, t.get("BsonDouble", 1d));
    assertEquals(123, t.get("BsonInt32", 1));
    assertEquals(123456L, t.get("BsonInt64", 1L));
    assertNull(t.get("BsonNull", "?"));
    assertEquals("abc", t.get("BsonRegularExpression", "?"));
    assertEquals("abcdefgh", t.get("BsonString", "?"));

    // String or Number
    date = t.get("BsonTimestamp", new Date());
    assertEquals(12000L, date.getTime());

    assertNull(t.get("BsonUndefined", "?"));
    assertEquals("abcdefgh", new String(t.get("Binary", "?".getBytes())));
    assertEquals("var a = 5;", t.get("Code", "?"));
    assertEquals(123456789L, t.get("Decimal128", 1L));
    assertEquals(objectID.toHexString(), t.get("ObjectId", "?"));
    assertEquals("s", t.get("Symbol", "?"));
}

@Test
public void testMongoTypes() throws Exception {
    Document doc = new Document();
    doc.put("BsonBoolean", new BsonBoolean(true));
    doc.put("BsonDateTime", new BsonDateTime(12345));
    doc.put("BsonDouble", new BsonDouble(123.456));
    doc.put("BsonInt32", new BsonInt32(123));
    doc.put("BsonInt64", new BsonInt64(123456));
    doc.put("BsonNull", new BsonNull());
    doc.put("BsonRegularExpression", new BsonRegularExpression("abc"));
    doc.put("BsonString", new BsonString("abcdefgh"));
    doc.put("BsonTimestamp", new BsonTimestamp(12, 23));
    doc.put("BsonUndefined", new BsonUndefined());
    doc.put("Binary", new Binary("abcdefgh".getBytes()));
    doc.put("Code", new Code("var a = 5;"));
    doc.put("Decimal128", new Decimal128(123456789));
    doc.put("ObjectId", new ObjectId());
    doc.put("Symbol", new Symbol("s"));

    Document map = new Document();
    map.put("a", "b");
    map.put("c", 5);
    doc.put("map", map);

    ArrayList<Object> list = new ArrayList<>();
    list.add("c");
    list.add("b");
    list.add("a");
    doc.put("list", list);

    Tree t = new Tree(doc, null);
    String json = t.toString();

    String writerClass = TreeWriterRegistry.getWriter(TreeWriterRegistry.JSON).getClass().toString();
    System.out.println("--------------------------------------------------------------");
    System.out.println("Output of " + writerClass + " serializer:");
    System.out.println(json);

    Tree t2 = new Tree(json);

    assertEquals(true, t2.get("BsonBoolean", false));
    // assertEquals(12345, t2.get("BsonDateTime", -1));
    assertEquals(123.456, t2.get("BsonDouble", 1d));
    assertEquals(123, t2.get("BsonInt32", 345));
    assertEquals(123456, t2.get("BsonInt64", 1));
    assertNull(t2.get("BsonNull", "X"));
    assertEquals("abc", t2.get("BsonRegularExpression", "xcf"));
    assertEquals("abcdefgh", t2.get("BsonString", "fsdfasdf"));
    // doc.put("BsonTimestamp", new BsonTimestamp(12, 23));
    // doc.put("BsonUndefined", new BsonUndefined());
    // doc.put("Binary", new Binary("abcdefgh".getBytes()));
    // doc.put("Code", new Code("var a = 5;"));
    // doc.put("Decimal128", new Decimal128(123456789));
    // doc.put("ObjectId", new ObjectId());
    // doc.put("Symbol", new Symbol("s"));
}

@Override
public BsonDecimal128 encode(BigDecimal object) {
    return new BsonDecimal128(new Decimal128(object));
}

@Override
public void encode(BsonWriter bsonWriter, BigDecimal value) {
    bsonWriter.writeDecimal128(new Decimal128(value));
}

@Test
public void testBigDecimal() {
    Number testNumber = new BigDecimal("3.141592654");
    BsonValue bsonValue = parser.serializeToBson(testNumber, null);
    Assert.assertEquals(new BsonDecimal128(Decimal128.parse("3.141592654")), bsonValue);
}

@Override
public void encode(BsonWriter writer, BigDecimal value,
        EncoderContext encoderContext) {
    writer.writeDecimal128(new Decimal128(value));
}

@Override
public void encode(BsonWriter writer, String value, EncoderContext encoderContext) {
    writer.writeDecimal128(Decimal128.parse(value));
}

@Override
public boolean accepts(TypeMirror type) {
    return Util.isSameType(type, Decimal128.class);
}

public Decimal128 getScalar() {
    return this.scalar;
}

public void setScalar(Decimal128 scalar) {
    this.scalar = scalar;
}

public Decimal128[] getArray() {
    return this.array;
}

public void setArray(Decimal128[] array) {
    this.array = array;
}

public Decimal128[][] getArray2() {
    return this.array2;
}

public void setArray2(Decimal128[][] array2) {
    this.array2 = array2;
}

public List<Decimal128> getList() {
    return this.list;
}

public void setList(List<Decimal128> list) {
    this.list = list;
}

public Set<Decimal128> getSet() {
    return this.set;
}

public void setSet(Set<Decimal128> set) {
    this.set = set;
}

public Map<String, Decimal128> getMap() {
    return this.map;
}

public void setMap(Map<String, Decimal128> map) {
    this.map = map;
}