private <S> S readNull() { if (this.typeToken.getRawType() == Optional.class) { return (S) Optional.absent(); } return null; }
@SuppressWarnings("unchecked") @Override public @Nullable <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { if (type.getRawType().equals(ByteString.class)) { return (TypeAdapter<T>) new ByteStringTypeAdapter(); } if (Message.class.isAssignableFrom(type.getRawType())) { return (TypeAdapter<T>) new MessageTypeAdapter(gson, type); } return null; } }
@Override @SuppressWarnings("unchecked") public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { Class<T> rawType = (Class<T>) type.getRawType(); if (Asset.class.isAssignableFrom(rawType)) { final Class<? extends Asset> assetClass = (Class<? extends Asset>) rawType;
@Override public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) { if (ClassUtils.isPrimitiveOrWrapper(type.getRawType()) || type.getType() instanceof GenericArrayType || CharSequence.class.isAssignableFrom(type.getRawType()) || (type.getType() instanceof ParameterizedType && (Collection.class.isAssignableFrom(type.getRawType()) || Map.class.isAssignableFrom(type.getRawType())))) { // delegate primitives, arrays, collections, and maps return null; } if (!this.baseClass.isAssignableFrom(type.getRawType())) { // delegate anything not assignable from base class return null; } TypeAdapter<R> adapter = new InterfaceAdapter<>(gson, this, type); return adapter; }
@SuppressWarnings("unchecked") MessageTypeAdapter(Gson gson, TypeToken<M> type) { this.gson = gson; this.messageAdapter = RuntimeMessageAdapter.create((Class<M>) type.getRawType()); Map<String, FieldBinding<M, B>> fieldBindings = new LinkedHashMap<>(); for (FieldBinding<M, B> binding : messageAdapter.fieldBindings().values()) { fieldBindings.put(binding.name, binding); } this.fieldBindings = unmodifiableMap(fieldBindings); }
@Override public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) { if (!baseClass.isAssignableFrom(type.getRawType())) { return null;
@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 <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { final Class<T> rawType = (Class<T>) type.getRawType(); if (!Uri.class.isAssignableFrom(rawType)) { return null;
@SuppressWarnings("unchecked") @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { Class<? super T> rawType = type.getRawType(); if (!containsTypeHandlerFor(rawType)) { return null; } return new GsonTypeHandlerAdapter<>((TypeHandler<T>) typeHandlerMap.get(rawType), gson, type); } }
@Override public void write(JsonWriter out, R value) throws IOException { if (Optional.class.isAssignableFrom(this.typeToken.getRawType())) { Optional opt = (Optional) value; if (opt != null && opt.isPresent()) { Object actualValue = opt.get(); writeObject(actualValue, out); } else { out.beginObject(); out.endObject(); } } else { writeObject(value, out); } }
@Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { Class<T> rawType = (Class<T>) type.getRawType(); if (!rawType.isEnum()) { return null;
@Override public R read(JsonReader in) throws IOException { JsonElement element = Streams.parse(in); if (element.isJsonNull()) { return readNull(); } JsonObject jsonObject = element.getAsJsonObject(); if (this.typeToken.getRawType() == Optional.class) { if (jsonObject.has(OBJECT_TYPE)) { return (R) Optional.of(readValue(jsonObject, null)); } else if (jsonObject.entrySet().isEmpty()) { return (R) Optional.absent(); } else { throw new IOException("No class found for Optional value."); } } return this.readValue(jsonObject, this.typeToken); }
Class<T> rawType = (Class<T>) type.getRawType(); if (!rawType.isEnum())
public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) { if (type.getRawType() != baseType) { return null;
public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) { if (type.getRawType() != baseType) { return null;
@Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) { boolean hasAdapter; try { TypeAdapter<T> adapter = gson.getDelegateAdapter(this, type); hasAdapter = !isReflectiveTypeAdapter(adapter); } catch (IllegalArgumentException e) { hasAdapter = false; } if (hasAdapter) { return null; } try { @SuppressWarnings("unchecked") Codec<T> codec = (Codec<T>) registry.get(type.getRawType()); return typeAdapterFromCodec(codec); } catch (CodecConfigurationException e1) { return null; } } };
@SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) { Class<? super T> rawType = typeToken.getRawType(); return (rawType == unboxed || rawType == boxed) ? (TypeAdapter<T>) typeAdapter : null; } @Override public String toString() {
@SuppressWarnings("unchecked") @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> targetType) { Class<? super T> rawType = targetType.getRawType(); JsonAdapter annotation = rawType.getAnnotation(JsonAdapter.class); if (annotation == null) { return null; } return (TypeAdapter<T>) getTypeAdapter(constructorConstructor, gson, targetType, annotation); }
@SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) { return typeToken.getRawType() == Date.class ? (TypeAdapter<T>) new DateTypeAdapter() : null; } };
@SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) { return typeToken.getRawType() == java.sql.Date.class ? (TypeAdapter<T>) new SqlDateTypeAdapter() : null; } };