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

项目：HZS.Durian 文件：JSONSerializers.java

static ClassMapBasedObjectSerializer addCommonSerializers() {
    ClassMapBasedObjectSerializer serializer = new ClassMapBasedObjectSerializer();

    serializer.addObjectSerializer(Object[].class, new ObjectArraySerializer(serializer));
    serializer.addObjectSerializer(Boolean.class, new ToStringSerializer());
    serializer.addObjectSerializer(Code.class, new CodeSerializer(serializer));
    serializer.addObjectSerializer(CodeWScope.class, new CodeWScopeSerializer(serializer));
    serializer.addObjectSerializer(DBObject.class, new DBObjectSerializer(serializer));
    serializer.addObjectSerializer(DBRefBase.class, new DBRefBaseSerializer(serializer));
    serializer.addObjectSerializer(Iterable.class, new IterableSerializer(serializer));
    serializer.addObjectSerializer(Map.class, new MapSerializer(serializer));
    serializer.addObjectSerializer(MaxKey.class, new MaxKeySerializer(serializer));
    serializer.addObjectSerializer(MinKey.class, new MinKeySerializer(serializer));
    serializer.addObjectSerializer(Number.class, new ToStringSerializer());
    serializer.addObjectSerializer(ObjectId.class, new ObjectIdSerializer(serializer));
    serializer.addObjectSerializer(Pattern.class, new PatternSerializer(serializer));
    serializer.addObjectSerializer(String.class, new StringSerializer());
    serializer.addObjectSerializer(UUID.class, new UUIDSerializer(serializer));
    return serializer;
}

项目：pentaho-mongodb-plugin 文件：MongodbInputDiscoverFieldsImpl.java

protected static int mongoToKettleType( Object fieldValue ) {
  if ( fieldValue == null ) {
    return ValueMetaInterface.TYPE_STRING;
  }

  if ( fieldValue instanceof Symbol || fieldValue instanceof String || fieldValue instanceof Code
        || fieldValue instanceof ObjectId || fieldValue instanceof MinKey || fieldValue instanceof MaxKey ) {
    return ValueMetaInterface.TYPE_STRING;
  } else if ( fieldValue instanceof Date ) {
    return ValueMetaInterface.TYPE_DATE;
  } else if ( fieldValue instanceof Number ) {
    // try to parse as an Integer
    try {
      Integer.parseInt( fieldValue.toString() );
      return ValueMetaInterface.TYPE_INTEGER;
    } catch ( NumberFormatException e ) {
      return ValueMetaInterface.TYPE_NUMBER;
    }
  } else if ( fieldValue instanceof Binary ) {
    return ValueMetaInterface.TYPE_BINARY;
  } else if ( fieldValue instanceof BSONTimestamp ) {
    return ValueMetaInterface.TYPE_INTEGER;
  }

  return ValueMetaInterface.TYPE_STRING;
}

项目：logdb 文件：MongoFindCommand.java

/**
 * convert bson types to java primitives. BasicBSONList, Binary,
 * BSONTimestamp, Code, CodeWScope, MinKey, MaxKey, Symbol, ObjectId
 */
private Object convert(Object o) {
    if (o instanceof BSONTimestamp) {
        return ((BSONTimestamp) o).getTime();
    } else if (o instanceof Symbol || o instanceof Code || o instanceof CodeWScope || o instanceof MinKey
            || o instanceof MaxKey || o instanceof ObjectId) {
        return o.toString();
    } else if (o instanceof BasicBSONList) {
        List<Object> l = new ArrayList<Object>();
        for (Object item : ((BasicBSONList) o)) {
            l.add(convert(item));
        }

        return l;
    } else {
        return o;
    }
}

项目：MongoWorkBench 文件：SystemJavaScriptReadCommand.java

@Override
public void execute() throws Exception {

    MongoClient mdb = MongoFactory.getInst().getMongo( sName );

    if ( mdb == null )
        throw new Exception("no server selected");

    if ( sDb == null )
        throw new Exception("no database selected");

    MongoFactory.getInst().setActiveDB(sDb);
    DB db   = mdb.getDB(sDb);

    DBCollection coll   = db.getCollection("system.js");
    DBObject dbo = coll.findOne( new BasicDBObject("_id", jsName) );

    if ( dbo.containsField("value") ){
        jsCode  = ((Code)dbo.get("value")).getCode();
    }

    setMessage("System JavaScript loaded=" + jsName);
}

项目：mongodm 文件：MObject.java

protected void checkValue(Object value) {
    if (value instanceof MObject)
        return;

    if (value == null)
        return;
    if (value instanceof Number)
        return;
    if (value instanceof String)
        return;
    if (value instanceof Boolean)
        return;
    if (value instanceof Character)
        return;
    if (value instanceof ObjectId)
        return;
    if (value instanceof Date)
        return;
    if (value instanceof Pattern)
        return;
    if (value instanceof UUID)
        return;
    if (value instanceof MaxKey || value instanceof MinKey)
        return;
    if (value instanceof byte[])
        return;
    if (value instanceof BSONTimestamp || value instanceof Symbol
        || value instanceof Code || value instanceof CodeWScope)
        return;

    throw new IllegalArgumentException(getClass().getSimpleName()
        + " can't store a " + value.getClass().getName());
}

项目：HZS.Durian 文件：JSONSerializers.java

@Override
public void serialize(Object obj, StringBuilder buf) {
    Code c = (Code) obj;
    BasicDBObject temp = new BasicDBObject();
    temp.put("$code", c.getCode());
    serializer.serialize(temp, buf);
}

项目：MongoWorkBench 文件：TreeWalker.java

private static Object toObject(TreeItem item){
    Class nodeClass = (Class)item.getData("class");

    if ( nodeClass == String.class ){
        return item.getText(1);
    } else if ( nodeClass == Boolean.class ){
        return StringUtil.toBoolean( item.getText(1), false );
    } else if ( nodeClass == Integer.class ){
        return StringUtil.toInteger( item.getText(1), Integer.MIN_VALUE);
    } else if ( nodeClass == Long.class ){
        return StringUtil.toLong(item.getText(1), Long.MIN_VALUE);
    } else if ( nodeClass == Double.class ){
        return StringUtil.toDouble(item.getText(1), Double.MIN_VALUE);
    } else if ( nodeClass == Date.class ){
        return DateUtil.parseDate(item.getText(1), "yyyy-MM-dd HH:mm:ss");
    } else if ( nodeClass == Code.class ){
        return new Code( item.getText(1) );
    } else if ( nodeClass == ObjectId.class ){
        return new ObjectId( item.getText(1) );
    } else if ( nodeClass == Pattern.class ){
        return Pattern.compile(item.getText(1));
    } else if ( nodeClass == Byte.class ){
    //TODO
        return null;
    } else
        return item.getText(1);
}

项目：datatree-adapters 文件：JsonJacksonBsonSerializers.java

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

项目：datatree-adapters 文件：YamlSnakeYamlBsonSerializers.java

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

}

项目：datatree-adapters 文件：JsonJohnzonBsonSerializers.java

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

}

项目：datatree-adapters 文件：JsonGensonBsonSerializers.java

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

}

项目：datatree-adapters 文件：JsonDSLBsonSerializers.java

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

}

项目：datatree-adapters 文件：MsgPackOrgBsonSerializers.java

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

}

项目：datatree-adapters 文件：JsonFastBsonSerializers.java

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

}

项目：datatree-adapters 文件：JsonJoddBsonSerializers.java

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

项目：datatree-adapters 文件：JsonFlexBsonSerializers.java

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

}

项目：datatree-adapters 文件：IonIonBsonSerializers.java

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

}

项目：datatree-adapters 文件：JsonGsonBsonSerializers.java

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

}

项目：datatree-adapters 文件：XmlXStreamBsonSerializers.java

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

}

项目：datatree-adapters 文件：ExtendedTreeTest.java

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

项目：datatree 文件：TreeTest.java

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

项目：BsonMapper 文件：BsonCodeConverter.java

@Override
public Code decode(BsonValue bsonValue) {
    return new Code(bsonValue.asJavaScript().getCode());
}

项目：BsonMapper 文件：BsonCodeConverter.java

@Override
public BsonJavaScript encode(Code object) {
    return new BsonJavaScript(object.getCode());
}

项目：BsonMapper 文件：BsonCodeConverter.java

@Override
public Code decode(BsonReader bsonReader) {
    return new Code(bsonReader.readJavaScript());
}

项目：BsonMapper 文件：BsonCodeConverter.java

@Override
public void encode(BsonWriter bsonWriter, Code value) {
    bsonWriter.writeJavaScript(value.getCode());
}

项目：HZS.Durian 文件：BasicBSONCallback.java

public void gotCode( String name , String code ){
    _put( name , new Code( code ) );
}

项目：HZS.Durian 文件：BasicBSONEncoder.java

protected void _putObjectField( String name , Object val ){

        if ( name.equals( "_transientFields" ) )
            return;

        if ( DEBUG ) System.out.println( "\t put thing : " + name );

        if ( name.contains( "\0" ) )
            throw new IllegalArgumentException( "Document field names can't have a NULL character. (Bad Key: '" + name + "')" );

        if ( name.equals( "$where") && val instanceof String ){
            _put( CODE , name );
            _putValueString( val.toString() );
            return;
        }

        val = BSON.applyEncodingHooks( val );

        if ( val == null )
            putNull(name);
        else if ( val instanceof Date )
            putDate( name , (Date)val );
        else if ( val instanceof Number )
            putNumber(name, (Number)val );
        else if ( val instanceof Character )
            putString(name, val.toString() );
        else if ( val instanceof String )
            putString(name, val.toString() );
        else if ( val instanceof ObjectId )
            putObjectId(name, (ObjectId)val );
        else if ( val instanceof BSONObject )
            putObject(name, (BSONObject)val );
        else if ( val instanceof Boolean )
            putBoolean(name, (Boolean)val );
        else if ( val instanceof Pattern )
            putPattern(name, (Pattern)val );
        else if ( val instanceof Map )
            putMap( name , (Map)val );
        else if ( val instanceof Iterable)
            putIterable( name , (Iterable)val );
        else if ( val instanceof byte[] )
            putBinary( name , (byte[])val );
        else if ( val instanceof Binary )
            putBinary( name , (Binary)val );
        else if ( val instanceof UUID )
            putUUID( name , (UUID)val );
        else if ( val.getClass().isArray() )
            putArray( name , val );

        else if (val instanceof Symbol) {
            putSymbol(name, (Symbol) val);
        }
        else if (val instanceof BSONTimestamp) {
            putTimestamp( name , (BSONTimestamp)val );
        }
        else if (val instanceof CodeWScope) {
            putCodeWScope( name , (CodeWScope)val );
        }
        else if (val instanceof Code) {
            putCode( name , (Code)val );
        }
        else if (val instanceof DBRefBase) {
            BSONObject temp = new BasicBSONObject();
            temp.put("$ref", ((DBRefBase)val).getRef());
            temp.put("$id", ((DBRefBase)val).getId());
            putObject( name, temp );
        }
        else if ( val instanceof MinKey )
            putMinKey( name );
        else if ( val instanceof MaxKey )
            putMaxKey( name );
        else if ( putSpecial( name , val ) ){
            // no-op
        }
        else {
            throw new IllegalArgumentException( "can't serialize " + val.getClass() );
        }

    }

项目：HZS.Durian 文件：BasicBSONEncoder.java

protected void putCode( String name , Code code ){
    _put( CODE , name );
    int temp = _buf.getPosition();
    _putValueString( code.getCode() );
}

项目：HZS.Durian 文件：LazyBSONObject.java

/**
 * @deprecated This method is NOT a part of public API and will be dropped in 3.x versions.
 */
@Deprecated
protected Object getElementValue( ElementRecord record ){
    switch ( record.type ){
        case BSON.EOO:
        case BSON.UNDEFINED:
        case BSON.NULL:
            return null;
        case BSON.MAXKEY:
            return new MaxKey();
        case BSON.MINKEY:
            return new MinKey();
        case BSON.BOOLEAN:
            return ( _input.get( record.valueOffset ) != 0 );
        case BSON.NUMBER_INT:
            return _input.getInt( record.valueOffset );
        case BSON.TIMESTAMP:
            int inc = _input.getInt( record.valueOffset );
            int time = _input.getInt( record.valueOffset + 4 );
            return new BSONTimestamp( time, inc );
        case BSON.DATE:
            return new Date( _input.getLong( record.valueOffset ) );
        case BSON.NUMBER_LONG:
            return _input.getLong( record.valueOffset );
        case BSON.NUMBER:
            return Double.longBitsToDouble( _input.getLong( record.valueOffset ) );
        case BSON.OID:
            return new ObjectId( _input.getIntBE( record.valueOffset ),
                                 _input.getIntBE( record.valueOffset + 4 ),
                                 _input.getIntBE( record.valueOffset + 8 ) );
        case BSON.SYMBOL:
            return new Symbol( _input.getUTF8String( record.valueOffset ) );
        case BSON.CODE:
            return new Code( _input.getUTF8String( record.valueOffset ) );
        case BSON.STRING:
            return _input.getUTF8String( record.valueOffset );
        case BSON.CODE_W_SCOPE:
            int strsize = _input.getInt( record.valueOffset + 4 );
            String code = _input.getUTF8String( record.valueOffset + 4 );
            BSONObject scope =
                    (BSONObject) _callback.createObject( _input.array(), record.valueOffset + 4 + 4 + strsize );
            return new CodeWScope( code, scope );
        case BSON.REF:
            int csize = _input.getInt( record.valueOffset );
            String ns = _input.getCString( record.valueOffset + 4 );
            int oidOffset = record.valueOffset + csize + 4;
            ObjectId oid = new ObjectId( _input.getIntBE( oidOffset ),
                                         _input.getIntBE( oidOffset + 4 ),
                                         _input.getIntBE( oidOffset + 8 ) );
            return _callback.createDBRef( ns, oid );
        case BSON.OBJECT:
            return _callback.createObject( _input.array(), record.valueOffset );
        case BSON.ARRAY:
            return _callback.createArray( _input.array(), record.valueOffset );
        case BSON.BINARY:
            return readBinary( record.valueOffset );
        case BSON.REGEX:
            int patternCStringSize = sizeCString( record.valueOffset );
            String pattern = _input.getCString( record.valueOffset );
            String flags = _input.getCString( record.valueOffset + patternCStringSize );
            return Pattern.compile( pattern, BSON.regexFlags( flags ) );
        default:
            throw new BSONException(
                    "Invalid type " + record.type + " for field " + getElementFieldName( record.offset ) );
    }
}

项目：HZS.Durian 文件：Bytes.java

/**
 * Gets the type byte for a given object.
 * @param o the object
 * @return the byte value associated with the type, or -1 if no type is matched
 */
@SuppressWarnings("deprecation")
public static byte getType( Object o ){
    if ( o == null )
        return NULL;

    if ( o instanceof DBPointer )
        return REF;

    if (o instanceof Integer
            || o instanceof Short
            || o instanceof Byte
            || o instanceof AtomicInteger) {
        return NUMBER_INT;
    }

    if (o instanceof Long || o instanceof AtomicLong) {
        return NUMBER_LONG;
    }

    if ( o instanceof Number )
        return NUMBER;

    if ( o instanceof String )
        return STRING;

    if ( o instanceof java.util.List )
        return ARRAY;

    if ( o instanceof byte[] )
        return BINARY;

    if ( o instanceof ObjectId )
        return OID;

    if ( o instanceof Boolean )
        return BOOLEAN;

    if ( o instanceof java.util.Date )
        return DATE;

    if ( o instanceof BSONTimestamp )
        return TIMESTAMP;

    if ( o instanceof java.util.regex.Pattern )
        return REGEX;

    if ( o instanceof DBObject || o instanceof DBRefBase )
        return OBJECT;

    if ( o instanceof Code )
        return CODE;

    if ( o instanceof CodeWScope )
        return CODE_W_SCOPE;

    return -1;
}

项目：MongoWorkBench 文件：MEditor.java

protected void showContextMenu(TreeItem treeItem) {

    menuManager.add( actionList[ACTION_INFO] );
    actionList[ACTION_INFO].setText( treeItem.getText(0) );

    menuManager.add( new Separator() );
    menuManager.add( actionList[ACTION_INSERT] );
    menuManager.add( actionList[ACTION_DELETE] );
    menuManager.add( new Separator() );

    // we are not allowing the main ObjectId to be messed around with
    Class nodeClass = (Class)treeItem.getData("class");
    if ( nodeClass == ObjectId.class || nodeClass == Map.class || nodeClass == List.class )
        return;

    Action action;
    for (int x=0; x < allTypes.length; x++ ){
        final int y = x;

        if ( allTypes[x].equals("objectid") || allTypes[x].equals("binary") )
            continue;

        action = new Action() {public void run() {actionRun(100+y);}    };
        action.setText( allTypes[x] );

        if ( nodeClass == String.class && allTypes[x].equals("string") )
            setActionImage(action, "tick.png");
        else if ( nodeClass == Double.class && allTypes[x].equals("double") )
            setActionImage(action, "tick.png");
        else if ( nodeClass == Integer.class && allTypes[x].equals("int32") )
            setActionImage(action, "tick.png");
        else if ( nodeClass == Long.class && allTypes[x].equals("int64") )
            setActionImage(action, "tick.png");
        else if ( nodeClass == Date.class && allTypes[x].equals("date") )
            setActionImage(action, "tick.png");
        else if ( nodeClass == Code.class && allTypes[x].equals("code") )
            setActionImage(action, "tick.png");
        else if ( nodeClass == Pattern.class && allTypes[x].equals("regex") )
            setActionImage(action, "tick.png");
        else if ( nodeClass == Boolean.class && allTypes[x].equals("boolean") )
            setActionImage(action, "tick.png");

        menuManager.add(action);
    }
}

项目：MongoWorkBench 文件：TreeRender.java

public static void setItemInfo(TreeItem treeItem, String key, Object value) {
    treeItem.setText(0, key);
    treeItem.setText(1, String.valueOf(value) );

    if (value instanceof Integer) {
        treeItem.setImage(intImage);
        treeItem.setText(2, "int32" );  
        treeItem.setData("class", Integer.class );
    } else if (value instanceof Long) {
        treeItem.setImage(longImage);
        treeItem.setText(2, "int64" );
        treeItem.setData("class", Long.class );
    } else if (value instanceof Double) {
        treeItem.setImage(doubleImage);
        treeItem.setText(2, "double" ); 
        treeItem.setData("class", Double.class );
    } else if (value instanceof Date) {
        treeItem.setImage(dateImage);
        treeItem.setText(2, "date" );
        treeItem.setText(1, DateUtil.getSQLDate( (Date)value ) );
        treeItem.setData("class", Date.class );
    } else if (value instanceof String) {
        treeItem.setImage(stringImage);
        treeItem.setText(2, "string" );
        treeItem.setData("class", String.class );
    } else if (value instanceof ObjectId) {
        treeItem.setImage(oidImage);
        treeItem.setText(2, "objectId" );
        treeItem.setData("class", ObjectId.class );
    } else if (value instanceof Boolean) {
        treeItem.setImage(boolImage);
        treeItem.setText(2, "boolean" );
        treeItem.setData("class", Boolean.class );
    } else if (value instanceof Code) {
        treeItem.setImage(jsImage);
        treeItem.setText(2, "code" );
        treeItem.setData("class", Code.class );
    } else if (value instanceof Pattern) {
        treeItem.setImage(jsImage);
        treeItem.setText(2, "regex" );
        treeItem.setData("class", Pattern.class );
    } else if ( value instanceof byte[] ){
        treeItem.setImage(jsImage);
        treeItem.setText(2, "binary" );
        treeItem.setText(1, "[bin " + ((byte[])value).length + " bytes]" );
        treeItem.setData("class", Byte.class );
    }
}

项目：MongoWorkBench 文件：SystemJavaScriptWriteCommand.java

@Override
public void execute() throws Exception {

    MongoClient mdb = MongoFactory.getInst().getMongo( sName );

    if ( mdb == null )
        throw new Exception("no server selected");

    if ( sDb == null )
        throw new Exception("no database selected");

    MongoFactory.getInst().setActiveDB(sDb);
    DB db   = mdb.getDB(sDb);

    DBCollection coll   = db.getCollection("system.js");

    BasicDBObject dbo = new BasicDBObject("_id", jsName).append("value", new Code(jsCode) );
    coll.save(dbo, WriteConcern.JOURNAL_SAFE);

    setMessage("System JavaScript Written=" + jsName);
}