JsonReaderSupplier(JsonReader in) throws IOException { this.element = TypeAdapters.JSON_ELEMENT.read(in); }
@Override public T decode(org.bson.BsonReader reader, DecoderContext decoderContext) { if (!(reader instanceof AbstractBsonReader)) { throw new UnsupportedOperationException(String.format("Only readers of type %s supported. Yours is %s", AbstractBsonReader.class.getName(), reader.getClass().getName())); } try { return adapter.read(new BsonReader((AbstractBsonReader) reader)); } catch (IOException e) { throw new RuntimeException(String.format("Couldn't read %s", clazz), e); } }
@Override public TimeInstant read(JsonReader in) throws IOException { return TimeInstant.of(TIME_INSTANT_ADAPTER.read(in)); }
@Override public Binary read(JsonReader in) throws IOException { return Binary.create(BINARY_ADAPTER.read(in)); }
@Override public Id read(JsonReader in) throws IOException { return Id.from(OBJECT_ID_ADAPTER.read(in)); }
@Override public T convert(ResponseBody value) throws IOException { JsonReader jsonReader = gson.newJsonReader(value.charStream()); try { T result = adapter.read(jsonReader); if (jsonReader.peek() != JsonToken.END_DOCUMENT) { throw new JsonIOException("JSON document was not fully consumed."); } return result; } finally { value.close(); } } }
@SuppressWarnings("unchecked") @Override public Object read(Gson gson, Type type, InputStream stream) throws IOException { @Nullable JsonReader reader = null; try { reader = createJsonReader(new BufferedReader(new InputStreamReader(stream, CHARSET_NAME))); options.setReaderOptions(reader); return gson.getAdapter((TypeToken<Object>) TypeToken.get(type)).read(reader); } catch (IOException ex) { throw ex; } catch (Exception ex) { throw new IOException(ex); } }
@SuppressWarnings("unchecked") @Override public T read(JsonReader in) throws IOException { List<Exception> exceptions = new ArrayList<>(subtypes.length); ReaderSupplier readerSupplier = readForSupplier(in); for (TypeAdapter<?> typeAdapter : adapters) { try { return (T) typeAdapter.read(readerSupplier.create()); } catch (Exception ex) { exceptions.add(ex); } } JsonParseException failure = new JsonParseException( String.format( "Cannot parse %s with following subtypes: %s", type, Arrays.toString(subtypes))); for (Exception exception : exceptions) { failure.addSuppressed(exception); } throw failure; }
ServerInfo entry = adapter.read(jsonReader); servers.add(entry);
@Override public T convert(ResponseBody value) throws IOException { JsonReader jsonReader = gson.newJsonReader(value.charStream()); try { return adapter.read(jsonReader); } finally { value.close(); } } }
static JsonObject toGson(BsonDocument bson) throws IOException { return TypeAdapters.JSON_ELEMENT.read(asGsonReader(bson)).getAsJsonObject(); } }
@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 T convert(ResponseBody value) throws IOException { JsonReader jsonReader = gson.newJsonReader(value.charStream()); try { T result = adapter.read(jsonReader); if (jsonReader.peek() != JsonToken.END_DOCUMENT) { throw new JsonIOException("JSON document was not fully consumed."); } return result; } finally { value.close(); } } }
@SuppressWarnings("unchecked") @Override public Object read(Gson gson, Type type, InputStream stream) throws IOException { @Nullable JsonReader reader = null; try { reader = new JsonParserReader(JSON_FACTORY.createParser(stream)); options.setReaderOptions(reader); return gson.getAdapter((TypeToken<Object>) TypeToken.get(type)).read(reader); } catch (IOException ex) { throw ex; } catch (Exception ex) { throw new IOException(ex); } finally { if (reader != null) { try { // note that stream is not closed here as per JSON_FACTORY configuration reader.close(); } catch (IOException ex) { // ignore io exception of reader close as not important } } } } }
@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(); } }; }
/** * 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()); }
private static void compare(String string) throws IOException { JsonElement bson = TypeAdapters.JSON_ELEMENT.read(new BsonReader(new JsonReader(string))); // compare as BSON JsonElement gson = TypeAdapters.JSON_ELEMENT.fromJson(string); // compare as JSON check(bson).is(gson); // compare the two }
@Override void read(JsonReader reader, Object value) throws IOException, IllegalAccessException { Object fieldValue = typeAdapter.read(reader); if (fieldValue != null || !isPrimitive) { field.set(value, fieldValue); } } @Override public boolean writeField(Object value) throws IOException, IllegalAccessException {
@Override public T read(JsonReader in) throws IOException { if (delegate == null) { throw new IllegalStateException(); } return delegate.read(in); }
@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); }