Refine search
@SuppressWarnings("unchecked") @Override public @Nullable M read(JsonReader in) throws IOException { if (in.peek() == JsonToken.NULL) { in.nextNull(); return null; } TypeAdapter<JsonElement> elementAdapter = gson.getAdapter(JsonElement.class); B builder = messageAdapter.newBuilder(); in.beginObject(); while (in.peek() != JsonToken.END_OBJECT) { String name = in.nextName(); FieldBinding<M, B> fieldBinding = fieldBindings.get(name); if (fieldBinding == null) { in.skipValue(); } else { JsonElement element = elementAdapter.read(in); Object value = parseValue(fieldBinding, element); fieldBinding.set(builder, value); } } in.endObject(); return builder.build(); }
@Override public void write(JsonWriter out, T value) throws IOException { if (value == null) { out.nullValue(); return; } for (int i = 0; i < subtypes.length; i++) { TypeToken<? extends T> subtype = subtypes[i]; if (subtype.getRawType().isInstance(value)) { // safe unchecked, type is checked at runtime @SuppressWarnings("unchecked") TypeAdapter<Object> typeAdapter = (TypeAdapter<Object>) adapters.get(i); typeAdapter.write(out, value); return; } } gson.toJson(value, value.getClass(), out); }
@Override public R read(JsonReader in) throws IOException { JsonElement jsonElement = Streams.parse(in); JsonElement labelJsonElement = jsonElement.getAsJsonObject().remove(typeFieldName); String label = (labelJsonElement == null ? null : labelJsonElement.getAsString()); @SuppressWarnings("unchecked") // registration requires that subtype extends T TypeAdapter<R> delegate = (TypeAdapter<R>) labelToDelegate.get(label); if (delegate == null) { throw new JsonParseException("cannot deserialize " + baseType + " subtype named " + label + "; did you forget to register a subtype?"); } return delegate.fromJsonTree(jsonElement); }
Class<?> valueClass; if (jsonElement.isJsonObject()) { JsonElement typeNameJsonElement = jsonElement.getAsJsonObject().remove(TYPE_FIELD_NAME); String typeName = typeNameJsonElement.getAsString(); TypeToken<?> valueType = TypeToken.get(valueClass); TypeAdapter<R> delegate = (TypeAdapter<R>) gson.getDelegateAdapter(PolymorphicTypeAdapterFactory.this, valueType); return delegate.fromJsonTree(jsonElement);
@Override public void write(JsonWriter out, T value) throws IOException { String kind = getKind(value); JsonObject json = getDelegateAdapter(kind).toJsonTree(value).getAsJsonObject(); json.addProperty(KIND, kind); gson.toJson(json, out); }
/** * 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 write(JsonWriter out, Map<K, V> map) throws IOException { if (map == null) { out.nullValue(); return; out.beginObject(); for (Map.Entry<K, V> entry : map.entrySet()) { out.name(String.valueOf(entry.getKey())); valueTypeAdapter.write(out, entry.getValue()); out.endObject(); JsonElement keyElement = keyTypeAdapter.toJsonTree(entry.getKey()); keys.add(keyElement); values.add(entry.getValue()); hasComplexKeys |= keyElement.isJsonArray() || keyElement.isJsonObject(); out.beginArray(); // entry array Streams.write(keys.get(i), out); valueTypeAdapter.write(out, values.get(i)); out.endArray(); JsonElement keyElement = keys.get(i); out.name(keyToString(keyElement)); valueTypeAdapter.write(out, values.get(i)); out.endObject();
private <S> S readValue(JsonObject jsonObject, TypeToken<S> defaultTypeToken) throws IOException { try { TypeToken<S> actualTypeToken; if (jsonObject.isJsonNull()) { return null; } else if (jsonObject.has(OBJECT_TYPE)) { String className = jsonObject.get(OBJECT_TYPE).getAsString(); Class<S> klazz = (Class<S>) Class.forName(className); actualTypeToken = TypeToken.get(klazz); } else if (defaultTypeToken != null) { actualTypeToken = defaultTypeToken; } else { throw new IOException("Could not determine TypeToken."); } TypeAdapter<S> delegate = this.gson.getDelegateAdapter(this.factory, actualTypeToken); S value = delegate.fromJsonTree(jsonObject.get(OBJECT_DATA)); return value; } catch (ClassNotFoundException cnfe) { throw new IOException(cnfe); } }
@SuppressWarnings("unchecked") @Override public void write(JsonWriter out, R value) throws IOException { Class<?> valueClass = value.getClass(); String valueTypeName = valueClass.getName(); TypeToken<?> valueType = TypeToken.get(valueClass); TypeAdapter<R> delegate = (TypeAdapter<R>) gson.getDelegateAdapter(PolymorphicTypeAdapterFactory.this, valueType); if (delegate == null) { throw new JsonParseException("Could not serialize " + valueClass.getName()); } JsonElement jsonElement = delegate.toJsonTree(value); if (valueClass != baseClass) { JsonObject jsonObject = jsonElement.getAsJsonObject(); JsonObject clone = new JsonObject(); clone.add(TYPE_FIELD_NAME, new JsonPrimitive(valueTypeName)); for (Map.Entry<String, JsonElement> e : jsonObject.entrySet()) { clone.add(e.getKey(), e.getValue()); } Streams.write(clone, out); } else { Streams.write(jsonElement, out); } }
@Override public void write(JsonWriter out, R value) throws IOException { Class<?> srcType = value.getClass(); String label = subtypeToLabel.get(srcType); @SuppressWarnings("unchecked") // registration requires that subtype extends T TypeAdapter<R> delegate = (TypeAdapter<R>) subtypeToDelegate.get(srcType); if (delegate == null) { throw new JsonParseException("cannot serialize " + srcType.getName() + "; did you forget to register a subtype?"); } JsonObject jsonObject = delegate.toJsonTree(value).getAsJsonObject(); if (jsonObject.has(typeFieldName) && !srcType.getSimpleName().equals("OldInput")) { throw new JsonParseException("cannot serialize " + srcType.getName() + " because it already defines a field named " + typeFieldName); } JsonObject clone = new JsonObject(); if (!srcType.getSimpleName().equals("OldInput")) { clone.add(typeFieldName, new JsonPrimitive(label)); } for (Map.Entry<String, JsonElement> e : jsonObject.entrySet()) { clone.add(e.getKey(), e.getValue()); } Streams.write(clone, out); } }.nullSafe();
static JsonObject toGson(BsonDocument bson) throws IOException { return TypeAdapters.JSON_ELEMENT.read(asGsonReader(bson)).getAsJsonObject(); } }
@Override public Map<K, V> read(JsonReader in) throws IOException { JsonToken peek = in.peek(); if (peek == JsonToken.NULL) { in.nextNull(); return null; in.beginArray(); while (in.hasNext()) { in.beginArray(); // entry array K key = keyTypeAdapter.read(in); V value = valueTypeAdapter.read(in); V replaced = map.put(key, value); if (replaced != null) { while (in.hasNext()) { JsonReaderInternalAccess.INSTANCE.promoteNameToValue(in); K key = keyTypeAdapter.read(in); V value = valueTypeAdapter.read(in); V replaced = map.put(key, value); if (replaced != null) {
@Override public Collection<E> read(JsonReader in) throws IOException { if (in.peek() == JsonToken.NULL) { in.nextNull(); return null; } Collection<E> collection = constructor.construct(); in.beginArray(); while (in.hasNext()) { E instance = elementTypeAdapter.read(in); collection.add(instance); } in.endArray(); return collection; }
@Override public Converter<ResponseBody, ?> responseBodyConverter( Type type, Annotation[] annotations, Retrofit retrofit) { // This converter requires an annotation providing the name of the payload in the envelope; // if one is not supplied then return null to continue down the converter chain. final String payloadName = getPayloadName(annotations); if (payloadName == null) return null; final TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type)); return (Converter<ResponseBody, Object>) body -> { try (JsonReader jsonReader = gson.newJsonReader(body.charStream())) { jsonReader.beginObject(); while (jsonReader.hasNext()) { if (payloadName.equals(jsonReader.nextName())) { return adapter.read(jsonReader); } else { jsonReader.skipValue(); } } return null; } finally { body.close(); } }; }
JsonReader jsonReader = new JsonReader(reader)) { jsonReader.beginArray(); TypeAdapter<ServerInfo> adapter = GSON.getAdapter(ServerInfo.class); while (jsonReader.hasNext()) { ServerInfo entry = adapter.read(jsonReader); servers.add(entry);
@Override public void write(JsonWriter out, Preference value) throws IOException { JsonObject object = preferenceTypeAdapter.toJsonTree(value).getAsJsonObject(); object.add("settings-class", new JsonPrimitive(value.settings.getClass().getName())); elementAdapter.write(out, object); }
@Override public T read(JsonReader in) throws IOException { if (deserializer == null) { return delegate().read(in); } JsonElement value = Streams.parse(in); if (value.isJsonNull()) { return null; } return deserializer.deserialize(value, typeToken.getType(), context); }
@Override public void write(JsonWriter out, Collection<E> collection) throws IOException { if (collection == null) { out.nullValue(); return; } out.beginArray(); for (E element : collection) { elementTypeAdapter.write(out, element); } out.endArray(); } }
@SuppressWarnings("unchecked") @Override public void write(JsonWriter out, Object value) throws IOException { if (value == null) { out.nullValue(); return; } TypeAdapter<Object> typeAdapter = (TypeAdapter<Object>) gson.getAdapter(value.getClass()); if (typeAdapter instanceof ObjectTypeAdapter) { out.beginObject(); out.endObject(); return; } typeAdapter.write(out, value); } }
@SuppressWarnings("unchecked") @Override public void write(Gson gson, Type type, Object object, OutputStream stream) throws IOException { @Nullable JsonWriter writer = null; boolean wasOriginalException = false; try { writer = new JsonWriter(new BufferedWriter(new OutputStreamWriter(stream, CHARSET_NAME))); options.setWriterOptions(writer); gson.getAdapter((TypeToken<Object>) TypeToken.get(type)).write(writer, object); } catch (IOException ex) { wasOriginalException = true; throw ex; } catch (Exception ex) { wasOriginalException = true; throw new IOException(ex); } finally { if (writer != null) { try { // underlying stream should not be closed, just flushing writer.flush(); } catch (IOException ex) { if (!wasOriginalException) { throw ex; } } } } }