Refine search
static Type getSuperclassTypeParameter(Class<?> subclass) { Type superclass = subclass.getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter."); } ParameterizedType parameterized = (ParameterizedType) superclass; return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]); }
/** * Gets type literal for the parameterized type represented by applying {@code typeArguments} to * {@code rawType}. */ public static TypeToken<?> getParameterized(Type rawType, Type... typeArguments) { return new TypeToken<Object>($Gson$Types.newParameterizedTypeWithOwner(null, rawType, typeArguments)); }
Type declaredType = type.getType(); while (raw != Object.class) { Field[] fields = raw.getDeclaredFields(); Type fieldType = $Gson$Types.resolve(type.getType(), raw, field.getGenericType()); List<String> fieldNames = getFieldNames(field); BoundField previous = null; if (i != 0) serialize = false; // only serialize the default name BoundField boundField = createBoundField(context, field, name, TypeToken.get(fieldType), serialize, deserialize); BoundField replaced = result.put(name, boundField); if (previous == null) previous = replaced; type = TypeToken.get($Gson$Types.resolve(type.getType(), raw, raw.getGenericSuperclass())); raw = type.getRawType();
public <T> Observable<List<T>> getObjectListObservable(Class<T> objectClass) { this.setType($Gson$Types.newParameterizedTypeWithOwner(null, List.class, objectClass)); this.setResponseAs(ResponseType.PARSED); if (this.getRequestType() == RequestType.SIMPLE) { return Rx2InternalNetworking.generateSimpleObservable(this); } else if (this.getRequestType() == RequestType.MULTIPART) { return Rx2InternalNetworking.generateMultipartObservable(this); } else { return null; } }
public void getAsObjectList(Class objectClass, ParsedRequestListener parsedRequestListener) { this.mType = $Gson$Types.newParameterizedTypeWithOwner(null, List.class, objectClass); this.mResponseType = ResponseType.PARSED; this.mParsedRequestListener = parsedRequestListener; ANRequestQueue.getInstance().addRequest(this); }
public void getAsOkHttpResponseAndObjectList(Class objectClass, OkHttpResponseAndParsedRequestListener parsedRequestListener) { this.mType = $Gson$Types.newParameterizedTypeWithOwner(null, List.class, objectClass); this.mResponseType = ResponseType.PARSED; this.mOkHttpResponseAndParsedRequestListener = parsedRequestListener; ANRequestQueue.getInstance().addRequest(this); }
public ANResponse executeForObjectList(Class objectClass) { this.mType = $Gson$Types.newParameterizedTypeWithOwner(null, List.class, objectClass); this.mResponseType = ResponseType.PARSED; return SynchronousCall.execute(this); }
public <T> Observable<List<T>> getObjectListObservable(Class<T> objectClass) { this.setType($Gson$Types.newParameterizedTypeWithOwner(null, List.class, objectClass)); this.setResponseAs(ResponseType.PARSED); if (this.getRequestType() == RequestType.SIMPLE) { return RxInternalNetworking.generateSimpleObservable(this); } else if (this.getRequestType() == RequestType.MULTIPART) { return RxInternalNetworking.generateMultipartObservable(this); } else { return null; } }
@Override public ObservableSource<? extends Boolean> apply(Boolean isEmpty) throws Exception { if (isEmpty) { Type type = $Gson$Types .newParameterizedTypeWithOwner(null, List.class, Question.class); List<Question> questionList = gson.fromJson( CommonUtils.loadJSONFromAsset(mContext, AppConstants.SEED_DATABASE_QUESTIONS), type); return saveQuestionList(questionList); } return Observable.just(false); } });
/** * Returns the type from super class's type parameter in {@link $Gson$Types#canonicalize * canonical form}. */ static Type getSuperclassTypeParameter(Class<?> subclass) { Type superclass = subclass.getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter."); } ParameterizedType parameterized = (ParameterizedType) superclass; return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]); }
@Override public String toString() { if (lowerBound != null) { return "? super " + typeToString(lowerBound); } else if (upperBound == Object.class) { return "?"; } else { return "? extends " + typeToString(upperBound); } }
/** * Unsafe. Constructs a type literal manually. */ @SuppressWarnings("unchecked") TypeToken(Type type) { this.type = $Gson$Types.canonicalize($Gson$Preconditions.checkNotNull(type)); this.rawType = (Class<? super T>) $Gson$Types.getRawType(this.type); this.hashCode = this.type.hashCode(); }
static Type getSuperclassTypeParameter(Class<?> subclass) { Type superclass = subclass.getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter."); } ParameterizedType parameterized = (ParameterizedType) superclass; return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]); }
@Override public String toString() { int length = typeArguments.length; if (length == 0) { return typeToString(rawType); } StringBuilder stringBuilder = new StringBuilder(30 * (length + 1)); stringBuilder.append(typeToString(rawType)).append("<").append(typeToString(typeArguments[0])); for (int i = 1; i < length; i++) { stringBuilder.append(", ").append(typeToString(typeArguments[i])); } return stringBuilder.append(">").toString(); }
static Type getSuperclassTypeParameter(Class<?> subclass) { Type superclass = subclass.getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter."); } ParameterizedType parameterized = (ParameterizedType) superclass; return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]); }
static Type resolveTypeVariable(Type context, Class<?> contextRawType, TypeVariable<?> unknown) { Class<?> declaredByRaw = declaringClassOf(unknown); // we can't reduce this further if (declaredByRaw == null) { return unknown; } Type declaredBy = getGenericSupertype(context, contextRawType, declaredByRaw); if (declaredBy instanceof ParameterizedType) { int index = indexOf(declaredByRaw.getTypeParameters(), unknown); return ((ParameterizedType) declaredBy).getActualTypeArguments()[index]; } return unknown; }
@Override public boolean equals(Object o) { return o instanceof GenericArrayType && $Gson$Types.equals(this, (GenericArrayType) o); }
static Type getSuperclassTypeParameter(Class<?> subclass) { Type superclass = subclass.getGenericSuperclass(); if (superclass instanceof Class) { throw new RuntimeException("Missing type parameter."); } ParameterizedType parameterized = (ParameterizedType) superclass; return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]); }
@Override public final boolean equals(Object o) { return o instanceof TypeToken<?> && $Gson$Types.equals(type, ((TypeToken<?>) o).type); }
@Override public boolean equals(Object other) { return other instanceof ParameterizedType && $Gson$Types.equals(this, (ParameterizedType) other); }