Java JsonNull.INSTANCE属性代码示例

@Override
public JsonElement serialize(EntityWrapper wrapper, Type type, JsonSerializationContext context) {
    if (wrapper == null) {
        return JsonNull.INSTANCE;
    }

    JsonObject root = new JsonObject();

    Entity entity = wrapper.get();
    root.add(KEY_IS_NULL, new JsonPrimitive(entity == null));

    if (entity != null) {
        root.add(KEY_TYPE, new JsonPrimitive(AttachmentsTypes.typeForInstance(entity)));
        root.add(KEY_ENTITY, context.serialize(entity));
    }

    return root;
}
 

private static JsonElement toJson(Object value) {
    if(value instanceof ConfigurationSection) {
        return toJson((ConfigurationSection) value);
    } else if(value instanceof Map) {
        return toJson((Map) value);
    } else if(value instanceof List) {
        return toJson((List) value);
    } else if(value instanceof String) {
        return new JsonPrimitive((String) value);
    } else if(value instanceof Character) {
        return new JsonPrimitive((Character) value);
    } else if(value instanceof Number) {
        return new JsonPrimitive((Number) value);
    } else if(value instanceof Boolean) {
        return new JsonPrimitive((Boolean) value);
    } else if(value == null) {
        return JsonNull.INSTANCE;
    } else {
        throw new IllegalArgumentException("Cannot coerce " + value.getClass().getSimpleName() + " to JSON");
    }
}
 

public static JsonElement parse(JsonReader reader) throws JsonParseException {
    boolean isEmpty = true;
    try {
        reader.peek();
        isEmpty = false;
        return (JsonElement) TypeAdapters.JSON_ELEMENT.read(reader);
    } catch (Throwable e) {
        if (isEmpty) {
            return JsonNull.INSTANCE;
        }
        throw new JsonSyntaxException(e);
    } catch (Throwable e2) {
        throw new JsonSyntaxException(e2);
    } catch (Throwable e22) {
        throw new JsonIOException(e22);
    } catch (Throwable e222) {
        throw new JsonSyntaxException(e222);
    }
}
 

/**
 * Jsonify.
 *
 * @param source the source
 * @return the json element
 */
public JsonElement jsonify(Object source) {
  JsonElement result = JsonNull.INSTANCE;
  if (source instanceof JsonElement) {
    result = (JsonElement) source;
  } else {
    try {
      result = GsonConvertor.getInstance().deserialize(source, JsonElement.class);

    } catch (ConvertorException e) {
      String msg = String.format("Could not deserialise object %s to json.", source);
      log.error(msg);
      log.debug(msg, e);
    }
  }
  return result;
}
 

/**
 * Gets the new element.
 *
 * @param type the type
 * @return the new element
 */
private JsonElement getNewElement(Class<? extends JsonElement> type) {
  JsonElement element = JsonNull.INSTANCE;
  if (JsonObject.class.equals(type)) {
    element = new JsonObject();
  } else if (JsonArray.class.equals(type)) {
    element = new JsonArray();
  } else {
    try {
      element = type.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
      log.error(String.format("Could not instantiate json element of type %s", type));
      log.debug(String.format("Could not instantiate json element of type %s.", type), e);
    }
  }
  return element;
}
 

@Override
public JsonObject toJson () {
	JsonObject object = super.toJson();
	JsonElement jsonName = name == null ? JsonNull.INSTANCE
			: new JsonPrimitive(name);
	object.add("name", jsonName);
	JsonElement jsonFields = JsonNull.INSTANCE;
	if (fields != null) {
		jsonFields = new JsonArray();
		for (int i = 0; i < fields.size(); i++) {
			JsonElement jsonFieldsItem = fields.get(i) == null ? JsonNull.INSTANCE
					: fields.get(i).toJson();
			((JsonArray) jsonFields).add(jsonFieldsItem);
		}
	}
	object.add("fields", jsonFields);
	return object;
}
 

@Override
public JsonObject toJson () {
	JsonObject object = super.toJson();
	JsonElement jsonPager = pager == null ? JsonNull.INSTANCE
			: pager.toJson();
	object.add("pager", jsonPager);
	JsonElement jsonSettings = JsonNull.INSTANCE;
	if (settings != null) {
		jsonSettings = new JsonArray();
		for (int i = 0; i < settings.size(); i++) {
			JsonElement jsonSettingsItem = settings.get(i) == null
					? JsonNull.INSTANCE : settings.get(i).toJson();
			((JsonArray) jsonSettings).add(jsonSettingsItem);
		}
	}
	object.add("settings", jsonSettings);
	return object;
}
 

@Override
public JsonElement serialize(ItemStack src, Type typeOfSrc, JsonSerializationContext context) {
  if(src == null) {
    return JsonNull.INSTANCE;
  }
  JsonObject res = new JsonObject();

  UniqueIdentifier id = GameRegistry.findUniqueIdentifierFor(src.getItem());
  res.addProperty("item", id.modId + ":" + id.name);
  res.addProperty("number", src.stackSize);
  res.addProperty("meta", src.getItemDamage());

  String nbt = serializeNBT(src.stackTagCompound);
  if(nbt != null && nbt.trim().length() > 0) {
    res.addProperty("nbt", nbt);
  }
  return res;
}
 

public static JsonElement fromJsonFile(File file)
{
    if(!file.exists())
    {
        return JsonNull.INSTANCE;
    }

    try
    {
        BufferedReader reader = new BufferedReader(new FileReader(file));
        JsonElement e = new JsonParser().parse(reader);
        reader.close();
        return e;
    }
    catch(Exception ex)
    {
        ex.printStackTrace();
    }

    return JsonNull.INSTANCE;
}
 

private JsonElement getJsonElement(Object param) {
  if (param == null) {
    return JsonNull.INSTANCE;
  }
  if (param instanceof JsonElement) {
    return cast(param);
  }
  if (param instanceof String) {
    return new JsonPrimitive((String) param);
  }
  if (param instanceof Boolean) {
    return new JsonPrimitive((Boolean) param);
  }
  if (param instanceof Double) {
    return new JsonPrimitive((Double) param);
  }
  try {
    return jsonParser.parse(DtoFactory.getInstance().toJson(param));
  } catch (IllegalArgumentException e) {
    return gson.toJsonTree(param);
  }
}
 

@Override
public JsonObject toJson() {
	JsonObject object = super.toJson();
	JsonElement jsonPermissions = JsonNull.INSTANCE;
	if (permissions != null) {
		jsonPermissions = new JsonArray();
		for (int i = 0; i < permissions.size(); i++) {
			JsonElement jsonPermissionsItem = permissions.get(i) == null ? JsonNull.INSTANCE : permissions.get(i).toJson();
			((JsonArray) jsonPermissions).add(jsonPermissionsItem);
		}
	}
	object.add("permissions", jsonPermissions);
	JsonElement jsonName = name == null ? JsonNull.INSTANCE : new JsonPrimitive(name);
	object.add("name", jsonName);
	JsonElement jsonDescription = description == null ? JsonNull.INSTANCE : new JsonPrimitive(description);
	object.add("description", jsonDescription);
	JsonElement jsonCode = code == null ? JsonNull.INSTANCE : new JsonPrimitive(code);
	object.add("code", jsonCode);
	return object;
}
 

@Override
public JsonObject toJson () {
	JsonObject object = super.toJson();
	JsonElement jsonMetas = JsonNull.INSTANCE;
	if (metas != null) {
		jsonMetas = new JsonArray();
		for (int i = 0; i < metas.size(); i++) {
			JsonElement jsonMetasItem = metas.get(i) == null
					? JsonNull.INSTANCE : metas.get(i).toJson();
			((JsonArray) jsonMetas).add(jsonMetasItem);
		}
	}
	object.add("metas", jsonMetas);
	JsonElement jsonPager = pager == null ? JsonNull.INSTANCE
			: pager.toJson();
	object.add("pager", jsonPager);
	return object;
}
 

private static JsonElement convert( Object object, Class<?> type, boolean serializeType ){
    if( object == null ){
        return JsonNull.INSTANCE;
    }
    else if( isSimple( object.getClass() ) ){
        return convertSimple( object, type, serializeType );
    }
    else if( isArray( object.getClass() ) ){
        return convertArray( object, type, serializeType );
    }
    else if( isCollection( object.getClass() ) ){
        return convertCollection( object, type, serializeType, true );
    }
    else if( isMap( object.getClass() ) ){
        return convertMap( object, type, serializeType );
    }
    else{
        return convertObject( object, type, serializeType );
    }
}
 

/**
 * Serialize
 *
 * @param src Date
 * @param typeOfSrc Type
 * @param context Json Serialization Context
 * @return Json Element
 */
@Override
public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
    if (src == null) {
        return JsonNull.INSTANCE;
    } else {
        return new JsonPrimitive(apiClient.formatDatetime(src));
    }
}
 

@Override
public JsonNull deserialize(TypeToken<?> type, ConfigurationNode node) throws ObjectMappingException {
    if (!type.equals(JSON_NULL_TYPE)) {
        throw new ObjectMappingException("Unable to map type: " + type.toString());
    }
    return JsonNull.INSTANCE;
}