Java 类org.bson.BsonNull 实例源码

public static BsonDocument getBsonDocument() {
    BsonDocument bsonObj = new BsonDocument().append("testDouble", new BsonDouble(20.777));
    List<BsonDocument> list = new ArrayList<BsonDocument>();
    list.add(bsonObj);
    list.add(bsonObj);
    byte[] bytes = new byte[3];
    bytes[0] = 3;
    bytes[1] = 2;
    bytes[2] = 1;
    BsonDocument bsonDocument = new BsonDocument().append("testDouble", new BsonDouble(20.99))
            .append("testString", new BsonString("testStringV"))
            .append("testArray", new BsonArray(list));
    return new BsonDocument().append("testDouble", new BsonDouble(20.99))
            .append("testString", new BsonString("testStringV"))
            .append("testArray", new BsonArray(list))
            .append("bson_test", bsonDocument)
            .append("testBinary", new BsonBinary(bytes))
            .append("testBsonUndefined", new BsonUndefined())
            .append("testObjectId", new BsonObjectId())
            .append("testStringObjectId", new BsonObjectId())
            .append("testBoolean", new BsonBoolean(true))
            .append("testDate", new BsonDateTime(time))
            .append("testNull", new BsonNull())
            .append("testInt", new BsonInt32(233))
            .append("testLong", new BsonInt64(233332));
}

@SuppressWarnings("unchecked")
public <T> BsonValue toBson(Object value, Class<T> clazz) {
    if(value == null) {
        return new BsonNull();
    }
    if(value instanceof BsonValue) {
        return (BsonValue) value;
    }
    final Codec<T> codec = registry.get(clazz);
    final String key = "value";
    final BsonDocument document = new BsonDocument();
    final BsonWriter writer = new BsonDocumentWriter(document);
    writer.writeStartDocument();
    writer.writeName(key);
    codec.encode(writer, (T) value, EncoderContext.builder().build());
    writer.writeEndDocument();
    return document.get(key);
}

private BsonValue fromGridRef(SmofGridRef fileRef, PrimaryField fieldOpts) {
    if(fileRef.isEmpty()) {
        return new BsonNull();
    }
    if(fileRef.getId() == null) {
        final SmofObject annotation = fieldOpts.getSmofAnnotationAs(SmofObject.class);
        if(fileRef.getBucketName() == null) {
            fileRef.setBucketName(annotation.bucketName());
        }
        //TODO test if upload file adds id to fileRef
        if(!annotation.preInsert() && !fieldOpts.isForcePreInsert()) {
            return new BsonLazyObjectId(fieldOpts.getName(), fileRef);
        }
        fieldOpts.setForcePreInsert(false);
        dispatcher.insert(fileRef);
    }
    final BsonDocument bsonRef = new BsonDocument("id", new BsonObjectId(fileRef.getId()))
            .append("bucket", new BsonString(fileRef.getBucketName()));
    return bsonRef;
}

/**
 * Return non-redundant timestamps of all graph element events
 * 
 * @return HashSet<Long> timestamps
 */
public TreeSet<Long> getTimestamps() {
    TreeSet<Long> timestampSet = new TreeSet<Long>();

    Function<BsonDateTime, Long> mapper = new Function<BsonDateTime, Long>() {
        @Override
        public Long apply(BsonDateTime val) {
            return val.getValue();
        }

    };
    edgeEvents.distinct(Tokens.TIMESTAMP, BsonDateTime.class)
            .filter(new BsonDocument(Tokens.TIMESTAMP, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(timestampSet);
    Set<Long> vtSet = new TreeSet<Long>();

    vertexEvents.distinct(Tokens.TIMESTAMP, BsonDateTime.class)
            .filter(new BsonDocument(Tokens.TIMESTAMP, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(vtSet);
    timestampSet.addAll(vtSet);

    return timestampSet;
}

public HashSet<Long> getTimestampsHashSet() {
    HashSet<Long> timestampSet = new HashSet<Long>();

    Function<BsonDateTime, Long> mapper = new Function<BsonDateTime, Long>() {
        @Override
        public Long apply(BsonDateTime val) {
            return val.getValue();
        }

    };
    edges.distinct(Tokens.TIMESTAMP, BsonDateTime.class)
            .filter(new BsonDocument(Tokens.TIMESTAMP, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(timestampSet);

    return timestampSet;
}

/**
 * Un-assigns a key/value property from the element. The object value of the
 * removed property is returned.
 *
 * @param key
 *            the key of the property to remove from the element
 * @return the object value associated with that key prior to removal. Should be
 *         instance of BsonValue
 */
@Override
public <T> T removeProperty(final String key) {
    try {
        BsonValue value = getProperty(key);
        BsonDocument filter = new BsonDocument();
        filter.put(Tokens.ID, new BsonString(this.id));
        BsonDocument update = new BsonDocument();
        update.put("$unset", new BsonDocument(key, new BsonNull()));
        if (this instanceof ChronoVertex) {
            graph.getVertexCollection().updateOne(filter, update, new UpdateOptions().upsert(true));
            return (T) value;
        } else {
            graph.getEdgeCollection().updateOne(filter, update, new UpdateOptions().upsert(true));
            return (T) value;
        }
    } catch (MongoWriteException e) {
        throw e;
    }
}

/**
 * Reading from BSON to GSON
 */
@Test
public void bsonToGson() throws Exception {
    BsonDocument document = new BsonDocument();
    document.append("boolean", new BsonBoolean(true));
    document.append("int32", new BsonInt32(32));
    document.append("int64", new BsonInt64(64));
    document.append("double", new BsonDouble(42.42D));
    document.append("string", new BsonString("foo"));
    document.append("null", new BsonNull());
    document.append("array", new BsonArray());
    document.append("object", new BsonDocument());

    JsonElement element = TypeAdapters.JSON_ELEMENT.read(new BsonReader(new BsonDocumentReader(document)));
    check(element.isJsonObject());

    check(element.getAsJsonObject().get("boolean").getAsJsonPrimitive().isBoolean());
    check(element.getAsJsonObject().get("boolean").getAsJsonPrimitive().getAsBoolean());

    check(element.getAsJsonObject().get("int32").getAsJsonPrimitive().isNumber());
    check(element.getAsJsonObject().get("int32").getAsJsonPrimitive().getAsNumber().intValue()).is(32);

    check(element.getAsJsonObject().get("int64").getAsJsonPrimitive().isNumber());
    check(element.getAsJsonObject().get("int64").getAsJsonPrimitive().getAsNumber().longValue()).is(64L);

    check(element.getAsJsonObject().get("double").getAsJsonPrimitive().isNumber());
    check(element.getAsJsonObject().get("double").getAsJsonPrimitive().getAsNumber().doubleValue()).is(42.42D);

    check(element.getAsJsonObject().get("string").getAsJsonPrimitive().isString());
    check(element.getAsJsonObject().get("string").getAsJsonPrimitive().getAsString()).is("foo");

    check(element.getAsJsonObject().get("null").isJsonNull());
    check(element.getAsJsonObject().get("array").isJsonArray());
    check(element.getAsJsonObject().get("object").isJsonObject());
}

public BsonValue toBson(Object value, SmofField field) {
    if(value == null) {
        return new BsonNull();
    }
    if(value instanceof BsonValue) {
        return (BsonValue) value;
    }
    if(field == null) {
        return toBson(value, value.getClass());
    }
    final SmofType type = field.getType();
    final BsonParser parser = parsers.get(type);
    return parser.toBson(value, field);
}

@Test
public void testNullType() throws IOException {
  BsonDocument bsonDoc = new BsonDocument();
  bsonDoc.append("nullKey", new BsonNull());
  writer.reset();
  bsonReader.write(writer, new BsonDocumentReader(bsonDoc));
  SingleMapReaderImpl mapReader = (SingleMapReaderImpl) writer.getMapVector().getReader();
  assertEquals(null, mapReader.reader("nullKey").readObject());
}

/**
 * Return an iterable to all the vertices in the graph. If this is not possible
 * for the implementation, then an UnsupportedOperationException can be thrown.
 *
 * @return an iterable reference to all vertices in the graph
 */
public Iterable<ChronoVertex> getChronoVertices() {
    HashSet<String> idSet = new HashSet<String>();
    Function<BsonString, String> mapper = new Function<BsonString, String>() {
        @Override
        public String apply(BsonString val) {
            return val.getValue();
        }

    };
    HashSet<String> outV = new HashSet<String>();
    edges.distinct(Tokens.OUT_VERTEX, BsonString.class)
            .filter(new BsonDocument(Tokens.OUT_VERTEX, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(outV);
    idSet.addAll(outV);
    HashSet<String> inV = new HashSet<String>();
    edges.distinct(Tokens.IN_VERTEX, BsonString.class)
            .filter(new BsonDocument(Tokens.IN_VERTEX, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(inV);
    idSet.addAll(inV);

    MongoCursor<BsonDocument> vi = vertices.find(Tokens.FLT_VERTEX_FIELD_NOT_INCLUDED)
            .projection(Tokens.PRJ_ONLY_ID).iterator();
    while (vi.hasNext()) {
        BsonDocument d = vi.next();
        idSet.add(d.getString(Tokens.ID).getValue());
    }

    HashSet<String> vertex = new HashSet<String>();
    vertices.distinct(Tokens.VERTEX, BsonString.class)
            .filter(new BsonDocument(Tokens.VERTEX, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(vertex);
    idSet.addAll(vertex);

    return idSet.parallelStream().map(s -> new ChronoVertex(s, this)).collect(Collectors.toSet());
}

/**
 * Return an iterable to all the vertices in the graph. If this is not possible
 * for the implementation, then an UnsupportedOperationException can be thrown.
 *
 * @return an iterable reference to all vertices in the graph
 */
public Stream<ChronoVertex> getChronoVertexStream(boolean isParallel) {
    HashSet<String> idSet = new HashSet<String>();
    Function<BsonString, String> mapper = new Function<BsonString, String>() {
        @Override
        public String apply(BsonString val) {
            return val.getValue();
        }

    };
    HashSet<String> outV = new HashSet<String>();
    edges.distinct(Tokens.OUT_VERTEX, BsonString.class)
            .filter(new BsonDocument(Tokens.OUT_VERTEX, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(outV);
    idSet.addAll(outV);
    HashSet<String> inV = new HashSet<String>();
    edges.distinct(Tokens.IN_VERTEX, BsonString.class)
            .filter(new BsonDocument(Tokens.IN_VERTEX, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(inV);
    idSet.addAll(inV);

    MongoCursor<BsonDocument> vi = vertices.find(Tokens.FLT_VERTEX_FIELD_NOT_INCLUDED)
            .projection(Tokens.PRJ_ONLY_ID).iterator();
    while (vi.hasNext()) {
        BsonDocument d = vi.next();
        idSet.add(d.getString(Tokens.ID).getValue());
    }

    HashSet<String> vertex = new HashSet<String>();
    vertices.distinct(Tokens.VERTEX, BsonString.class)
            .filter(new BsonDocument(Tokens.VERTEX, new BsonDocument(Tokens.FC.$ne.toString(), new BsonNull())))
            .map(mapper).into(vertex);
    idSet.addAll(vertex);
    if (isParallel)
        return idSet.parallelStream().map(s -> new ChronoVertex(s, this)).collect(Collectors.toSet())
                .parallelStream();
    else
        return idSet.parallelStream().map(s -> new ChronoVertex(s, this)).collect(Collectors.toSet()).stream();
}

@Override
public void transform(
        HttpServerExchange exchange,
        RequestContext context,
        BsonValue contentToTransform,
        BsonValue args) {
    if (context.getDbOperationResult() == null) {
    } else {
        BsonDocument resp = null;

        if (contentToTransform == null || !contentToTransform.isDocument()) {
            resp = new BsonDocument();
            context.setResponseContent(resp);
        } else if (contentToTransform.isDocument()) {
            resp = contentToTransform.asDocument();
        }

        if (resp != null) {
            resp.append("oldData", context.getDbOperationResult().getOldData()
                    == null
                            ? new BsonNull()
                            : context.getDbOperationResult().getOldData());

            resp.append("newData", context.getDbOperationResult().getNewData()
                    == null
                            ? new BsonNull()
                            : context.getDbOperationResult().getNewData());
        }
    }
}

/**
 * Reading from BSON to GSON
 */
@Test
public void bsonToGson() throws Exception {
  BsonDocument document = new BsonDocument();
  document.append("boolean", new BsonBoolean(true));
  document.append("int32", new BsonInt32(32));
  document.append("int64", new BsonInt64(64));
  document.append("double", new BsonDouble(42.42D));
  document.append("string", new BsonString("foo"));
  document.append("null", new BsonNull());
  document.append("array", new BsonArray());
  document.append("object", new BsonDocument());

  JsonElement element = TypeAdapters.JSON_ELEMENT.read(new BsonReader(new BsonDocumentReader(document)));
  check(element.isJsonObject());

  check(element.getAsJsonObject().get("boolean").getAsJsonPrimitive().isBoolean());
  check(element.getAsJsonObject().get("boolean").getAsJsonPrimitive().getAsBoolean());

  check(element.getAsJsonObject().get("int32").getAsJsonPrimitive().isNumber());
  check(element.getAsJsonObject().get("int32").getAsJsonPrimitive().getAsNumber().intValue()).is(32);

  check(element.getAsJsonObject().get("int64").getAsJsonPrimitive().isNumber());
  check(element.getAsJsonObject().get("int64").getAsJsonPrimitive().getAsNumber().longValue()).is(64L);

  check(element.getAsJsonObject().get("double").getAsJsonPrimitive().isNumber());
  check(element.getAsJsonObject().get("double").getAsJsonPrimitive().getAsNumber().doubleValue()).is(42.42D);

  check(element.getAsJsonObject().get("string").getAsJsonPrimitive().isString());
  check(element.getAsJsonObject().get("string").getAsJsonPrimitive().getAsString()).is("foo");

  check(element.getAsJsonObject().get("null").isJsonNull());
  check(element.getAsJsonObject().get("array").isJsonArray());
  check(element.getAsJsonObject().get("object").isJsonObject());
}

@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();
    });

}

@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", "?"));
}