mirror of
https://github.com/fankes/moshi.git
synced 2025-10-18 23:49:21 +08:00
Convert Types to Kotlin (#1488)
This commit is contained in:
Zac Sweers
GitHub
@@ -1,386 +0,0 @@
|
|||||||
/*
|
|
||||||
* Copyright (C) 2008 Google Inc.
|
|
||||||
*
|
|
||||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
||||||
* you may not use this file except in compliance with the License.
|
|
||||||
* You may obtain a copy of the License at
|
|
||||||
*
|
|
||||||
* http://www.apache.org/licenses/LICENSE-2.0
|
|
||||||
*
|
|
||||||
* Unless required by applicable law or agreed to in writing, software
|
|
||||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
||||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
||||||
* See the License for the specific language governing permissions and
|
|
||||||
* limitations under the License.
|
|
||||||
*/
|
|
||||||
package com.squareup.moshi;
|
|
||||||
|
|
||||||
import static com.squareup.moshi.internal.Util.EMPTY_TYPE_ARRAY;
|
|
||||||
import static com.squareup.moshi.internal.Util.getGenericSupertype;
|
|
||||||
import static com.squareup.moshi.internal.Util.resolve;
|
|
||||||
|
|
||||||
import com.squareup.moshi.internal.GenericArrayTypeImpl;
|
|
||||||
import com.squareup.moshi.internal.ParameterizedTypeImpl;
|
|
||||||
import com.squareup.moshi.internal.WildcardTypeImpl;
|
|
||||||
import java.lang.annotation.Annotation;
|
|
||||||
import java.lang.reflect.Array;
|
|
||||||
import java.lang.reflect.Field;
|
|
||||||
import java.lang.reflect.GenericArrayType;
|
|
||||||
import java.lang.reflect.InvocationHandler;
|
|
||||||
import java.lang.reflect.Method;
|
|
||||||
import java.lang.reflect.ParameterizedType;
|
|
||||||
import java.lang.reflect.Proxy;
|
|
||||||
import java.lang.reflect.Type;
|
|
||||||
import java.lang.reflect.TypeVariable;
|
|
||||||
import java.lang.reflect.WildcardType;
|
|
||||||
import java.util.Arrays;
|
|
||||||
import java.util.Collection;
|
|
||||||
import java.util.Collections;
|
|
||||||
import java.util.LinkedHashSet;
|
|
||||||
import java.util.Map;
|
|
||||||
import java.util.Properties;
|
|
||||||
import java.util.Set;
|
|
||||||
import javax.annotation.CheckReturnValue;
|
|
||||||
import javax.annotation.Nullable;
|
|
||||||
|
|
||||||
/** Factory methods for types. */
|
|
||||||
@CheckReturnValue
|
|
||||||
public final class Types {
|
|
||||||
private Types() {}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Resolves the generated {@link JsonAdapter} fully qualified class name for a given {@link
|
|
||||||
* JsonClass JsonClass-annotated} {@code clazz}. This is the same lookup logic used by both the
|
|
||||||
* Moshi code generation as well as lookup for any JsonClass-annotated classes. This can be useful
|
|
||||||
* if generating your own JsonAdapters without using Moshi's first party code gen.
|
|
||||||
*
|
|
||||||
* @param clazz the class to calculate a generated JsonAdapter name for.
|
|
||||||
* @return the resolved fully qualified class name to the expected generated JsonAdapter class.
|
|
||||||
* Note that this name will always be a top-level class name and not a nested class.
|
|
||||||
*/
|
|
||||||
public static String generatedJsonAdapterName(Class<?> clazz) {
|
|
||||||
if (clazz.getAnnotation(JsonClass.class) == null) {
|
|
||||||
throw new IllegalArgumentException("Class does not have a JsonClass annotation: " + clazz);
|
|
||||||
}
|
|
||||||
return generatedJsonAdapterName(clazz.getName());
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Resolves the generated {@link JsonAdapter} fully qualified class name for a given {@link
|
|
||||||
* JsonClass JsonClass-annotated} {@code className}. This is the same lookup logic used by both
|
|
||||||
* the Moshi code generation as well as lookup for any JsonClass-annotated classes. This can be
|
|
||||||
* useful if generating your own JsonAdapters without using Moshi's first party code gen.
|
|
||||||
*
|
|
||||||
* @param className the fully qualified class to calculate a generated JsonAdapter name for.
|
|
||||||
* @return the resolved fully qualified class name to the expected generated JsonAdapter class.
|
|
||||||
* Note that this name will always be a top-level class name and not a nested class.
|
|
||||||
*/
|
|
||||||
public static String generatedJsonAdapterName(String className) {
|
|
||||||
return className.replace("$", "_") + "JsonAdapter";
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Checks if {@code annotations} contains {@code jsonQualifier}. Returns the subset of {@code
|
|
||||||
* annotations} without {@code jsonQualifier}, or null if {@code annotations} does not contain
|
|
||||||
* {@code jsonQualifier}.
|
|
||||||
*/
|
|
||||||
public static @Nullable Set<? extends Annotation> nextAnnotations(
|
|
||||||
Set<? extends Annotation> annotations, Class<? extends Annotation> jsonQualifier) {
|
|
||||||
if (!jsonQualifier.isAnnotationPresent(JsonQualifier.class)) {
|
|
||||||
throw new IllegalArgumentException(jsonQualifier + " is not a JsonQualifier.");
|
|
||||||
}
|
|
||||||
if (annotations.isEmpty()) {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
for (Annotation annotation : annotations) {
|
|
||||||
if (jsonQualifier.equals(annotation.annotationType())) {
|
|
||||||
Set<? extends Annotation> delegateAnnotations = new LinkedHashSet<>(annotations);
|
|
||||||
delegateAnnotations.remove(annotation);
|
|
||||||
return Collections.unmodifiableSet(delegateAnnotations);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a new parameterized type, applying {@code typeArguments} to {@code rawType}. Use this
|
|
||||||
* method if {@code rawType} is not enclosed in another type.
|
|
||||||
*/
|
|
||||||
public static ParameterizedType newParameterizedType(Type rawType, Type... typeArguments) {
|
|
||||||
if (typeArguments.length == 0) {
|
|
||||||
throw new IllegalArgumentException("Missing type arguments for " + rawType);
|
|
||||||
}
|
|
||||||
return ParameterizedTypeImpl.create(null, rawType, typeArguments);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a new parameterized type, applying {@code typeArguments} to {@code rawType}. Use this
|
|
||||||
* method if {@code rawType} is enclosed in {@code ownerType}.
|
|
||||||
*/
|
|
||||||
public static ParameterizedType newParameterizedTypeWithOwner(
|
|
||||||
Type ownerType, Type rawType, Type... typeArguments) {
|
|
||||||
if (typeArguments.length == 0) {
|
|
||||||
throw new IllegalArgumentException("Missing type arguments for " + rawType);
|
|
||||||
}
|
|
||||||
return ParameterizedTypeImpl.create(ownerType, rawType, typeArguments);
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Returns an array type whose elements are all instances of {@code componentType}. */
|
|
||||||
public static GenericArrayType arrayOf(Type componentType) {
|
|
||||||
return GenericArrayTypeImpl.create(componentType);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a type that represents an unknown type that extends {@code bound}. For example, if
|
|
||||||
* {@code bound} is {@code CharSequence.class}, this returns {@code ? extends CharSequence}. If
|
|
||||||
* {@code bound} is {@code Object.class}, this returns {@code ?}, which is shorthand for {@code ?
|
|
||||||
* extends Object}.
|
|
||||||
*/
|
|
||||||
public static WildcardType subtypeOf(Type bound) {
|
|
||||||
Type[] upperBounds;
|
|
||||||
if (bound instanceof WildcardType) {
|
|
||||||
upperBounds = ((WildcardType) bound).getUpperBounds();
|
|
||||||
} else {
|
|
||||||
upperBounds = new Type[] {bound};
|
|
||||||
}
|
|
||||||
return WildcardTypeImpl.create(upperBounds, EMPTY_TYPE_ARRAY);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a type that represents an unknown supertype of {@code bound}. For example, if {@code
|
|
||||||
* bound} is {@code String.class}, this returns {@code ? super String}.
|
|
||||||
*/
|
|
||||||
public static WildcardType supertypeOf(Type bound) {
|
|
||||||
Type[] lowerBounds;
|
|
||||||
if (bound instanceof WildcardType) {
|
|
||||||
lowerBounds = ((WildcardType) bound).getLowerBounds();
|
|
||||||
} else {
|
|
||||||
lowerBounds = new Type[] {bound};
|
|
||||||
}
|
|
||||||
return WildcardTypeImpl.create(new Type[] {Object.class}, lowerBounds);
|
|
||||||
}
|
|
||||||
|
|
||||||
public static Class<?> getRawType(Type type) {
|
|
||||||
if (type instanceof Class<?>) {
|
|
||||||
// type is a normal class.
|
|
||||||
return (Class<?>) type;
|
|
||||||
|
|
||||||
} else if (type instanceof ParameterizedType) {
|
|
||||||
ParameterizedType parameterizedType = (ParameterizedType) type;
|
|
||||||
|
|
||||||
// I'm not exactly sure why getRawType() returns Type instead of Class. Neal isn't either but
|
|
||||||
// suspects some pathological case related to nested classes exists.
|
|
||||||
Type rawType = parameterizedType.getRawType();
|
|
||||||
return (Class<?>) rawType;
|
|
||||||
|
|
||||||
} else if (type instanceof GenericArrayType) {
|
|
||||||
Type componentType = ((GenericArrayType) type).getGenericComponentType();
|
|
||||||
return Array.newInstance(getRawType(componentType), 0).getClass();
|
|
||||||
|
|
||||||
} else if (type instanceof TypeVariable) {
|
|
||||||
// We could use the variable's bounds, but that won't work if there are multiple. having a raw
|
|
||||||
// type that's more general than necessary is okay.
|
|
||||||
return Object.class;
|
|
||||||
|
|
||||||
} else if (type instanceof WildcardType) {
|
|
||||||
return getRawType(((WildcardType) type).getUpperBounds()[0]);
|
|
||||||
|
|
||||||
} else {
|
|
||||||
String className = type == null ? "null" : type.getClass().getName();
|
|
||||||
throw new IllegalArgumentException(
|
|
||||||
"Expected a Class, ParameterizedType, or "
|
|
||||||
+ "GenericArrayType, but <"
|
|
||||||
+ type
|
|
||||||
+ "> is of type "
|
|
||||||
+ className);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the element type of this collection type.
|
|
||||||
*
|
|
||||||
* @throws IllegalArgumentException if this type is not a collection.
|
|
||||||
*/
|
|
||||||
public static Type collectionElementType(Type context, Class<?> contextRawType) {
|
|
||||||
Type collectionType = getSupertype(context, contextRawType, Collection.class);
|
|
||||||
|
|
||||||
if (collectionType instanceof WildcardType) {
|
|
||||||
collectionType = ((WildcardType) collectionType).getUpperBounds()[0];
|
|
||||||
}
|
|
||||||
if (collectionType instanceof ParameterizedType) {
|
|
||||||
return ((ParameterizedType) collectionType).getActualTypeArguments()[0];
|
|
||||||
}
|
|
||||||
return Object.class;
|
|
||||||
}
|
|
||||||
|
|
||||||
/** Returns true if {@code a} and {@code b} are equal. */
|
|
||||||
public static boolean equals(@Nullable Type a, @Nullable Type b) {
|
|
||||||
if (a == b) {
|
|
||||||
return true; // Also handles (a == null && b == null).
|
|
||||||
|
|
||||||
} else if (a instanceof Class) {
|
|
||||||
if (b instanceof GenericArrayType) {
|
|
||||||
return equals(
|
|
||||||
((Class) a).getComponentType(), ((GenericArrayType) b).getGenericComponentType());
|
|
||||||
}
|
|
||||||
return a.equals(b); // Class already specifies equals().
|
|
||||||
|
|
||||||
} else if (a instanceof ParameterizedType) {
|
|
||||||
if (!(b instanceof ParameterizedType)) return false;
|
|
||||||
ParameterizedType pa = (ParameterizedType) a;
|
|
||||||
ParameterizedType pb = (ParameterizedType) b;
|
|
||||||
Type[] aTypeArguments =
|
|
||||||
pa instanceof ParameterizedTypeImpl
|
|
||||||
? ((ParameterizedTypeImpl) pa).typeArguments
|
|
||||||
: pa.getActualTypeArguments();
|
|
||||||
Type[] bTypeArguments =
|
|
||||||
pb instanceof ParameterizedTypeImpl
|
|
||||||
? ((ParameterizedTypeImpl) pb).typeArguments
|
|
||||||
: pb.getActualTypeArguments();
|
|
||||||
return equals(pa.getOwnerType(), pb.getOwnerType())
|
|
||||||
&& pa.getRawType().equals(pb.getRawType())
|
|
||||||
&& Arrays.equals(aTypeArguments, bTypeArguments);
|
|
||||||
|
|
||||||
} else if (a instanceof GenericArrayType) {
|
|
||||||
if (b instanceof Class) {
|
|
||||||
return equals(
|
|
||||||
((Class) b).getComponentType(), ((GenericArrayType) a).getGenericComponentType());
|
|
||||||
}
|
|
||||||
if (!(b instanceof GenericArrayType)) return false;
|
|
||||||
GenericArrayType ga = (GenericArrayType) a;
|
|
||||||
GenericArrayType gb = (GenericArrayType) b;
|
|
||||||
return equals(ga.getGenericComponentType(), gb.getGenericComponentType());
|
|
||||||
|
|
||||||
} else if (a instanceof WildcardType) {
|
|
||||||
if (!(b instanceof WildcardType)) return false;
|
|
||||||
WildcardType wa = (WildcardType) a;
|
|
||||||
WildcardType wb = (WildcardType) b;
|
|
||||||
return Arrays.equals(wa.getUpperBounds(), wb.getUpperBounds())
|
|
||||||
&& Arrays.equals(wa.getLowerBounds(), wb.getLowerBounds());
|
|
||||||
|
|
||||||
} else if (a instanceof TypeVariable) {
|
|
||||||
if (!(b instanceof TypeVariable)) return false;
|
|
||||||
TypeVariable<?> va = (TypeVariable<?>) a;
|
|
||||||
TypeVariable<?> vb = (TypeVariable<?>) b;
|
|
||||||
return va.getGenericDeclaration() == vb.getGenericDeclaration()
|
|
||||||
&& va.getName().equals(vb.getName());
|
|
||||||
|
|
||||||
} else {
|
|
||||||
// This isn't a supported type.
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* @param clazz the target class to read the {@code fieldName} field annotations from.
|
|
||||||
* @param fieldName the target field name on {@code clazz}.
|
|
||||||
* @return a set of {@link JsonQualifier}-annotated {@link Annotation} instances retrieved from
|
|
||||||
* the targeted field. Can be empty if none are found.
|
|
||||||
* @deprecated this is no longer needed in Kotlin 1.6.0 (which has direct annotation
|
|
||||||
* instantiation) and is obsolete.
|
|
||||||
*/
|
|
||||||
@Deprecated
|
|
||||||
public static Set<? extends Annotation> getFieldJsonQualifierAnnotations(
|
|
||||||
Class<?> clazz, String fieldName) {
|
|
||||||
try {
|
|
||||||
Field field = clazz.getDeclaredField(fieldName);
|
|
||||||
field.setAccessible(true);
|
|
||||||
Annotation[] fieldAnnotations = field.getDeclaredAnnotations();
|
|
||||||
Set<Annotation> annotations = new LinkedHashSet<>(fieldAnnotations.length);
|
|
||||||
for (Annotation annotation : fieldAnnotations) {
|
|
||||||
if (annotation.annotationType().isAnnotationPresent(JsonQualifier.class)) {
|
|
||||||
annotations.add(annotation);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return Collections.unmodifiableSet(annotations);
|
|
||||||
} catch (NoSuchFieldException e) {
|
|
||||||
throw new IllegalArgumentException(
|
|
||||||
"Could not access field " + fieldName + " on class " + clazz.getCanonicalName(), e);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@SuppressWarnings("unchecked")
|
|
||||||
static <T extends Annotation> T createJsonQualifierImplementation(final Class<T> annotationType) {
|
|
||||||
if (!annotationType.isAnnotation()) {
|
|
||||||
throw new IllegalArgumentException(annotationType + " must be an annotation.");
|
|
||||||
}
|
|
||||||
if (!annotationType.isAnnotationPresent(JsonQualifier.class)) {
|
|
||||||
throw new IllegalArgumentException(annotationType + " must have @JsonQualifier.");
|
|
||||||
}
|
|
||||||
if (annotationType.getDeclaredMethods().length != 0) {
|
|
||||||
throw new IllegalArgumentException(annotationType + " must not declare methods.");
|
|
||||||
}
|
|
||||||
return (T)
|
|
||||||
Proxy.newProxyInstance(
|
|
||||||
annotationType.getClassLoader(),
|
|
||||||
new Class<?>[] {annotationType},
|
|
||||||
new InvocationHandler() {
|
|
||||||
@Override
|
|
||||||
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
|
|
||||||
String methodName = method.getName();
|
|
||||||
switch (methodName) {
|
|
||||||
case "annotationType":
|
|
||||||
return annotationType;
|
|
||||||
case "equals":
|
|
||||||
Object o = args[0];
|
|
||||||
return annotationType.isInstance(o);
|
|
||||||
case "hashCode":
|
|
||||||
return 0;
|
|
||||||
case "toString":
|
|
||||||
return "@" + annotationType.getName() + "()";
|
|
||||||
default:
|
|
||||||
return method.invoke(proxy, args);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns a two element array containing this map's key and value types in positions 0 and 1
|
|
||||||
* respectively.
|
|
||||||
*/
|
|
||||||
static Type[] mapKeyAndValueTypes(Type context, Class<?> contextRawType) {
|
|
||||||
// Work around a problem with the declaration of java.util.Properties. That class should extend
|
|
||||||
// Hashtable<String, String>, but it's declared to extend Hashtable<Object, Object>.
|
|
||||||
if (context == Properties.class) return new Type[] {String.class, String.class};
|
|
||||||
|
|
||||||
Type mapType = getSupertype(context, contextRawType, Map.class);
|
|
||||||
if (mapType instanceof ParameterizedType) {
|
|
||||||
ParameterizedType mapParameterizedType = (ParameterizedType) mapType;
|
|
||||||
return mapParameterizedType.getActualTypeArguments();
|
|
||||||
}
|
|
||||||
return new Type[] {Object.class, Object.class};
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the generic form of {@code supertype}. For example, if this is {@code
|
|
||||||
* ArrayList<String>}, this returns {@code Iterable<String>} given the input {@code
|
|
||||||
* Iterable.class}.
|
|
||||||
*
|
|
||||||
* @param supertype a superclass of, or interface implemented by, this.
|
|
||||||
*/
|
|
||||||
static Type getSupertype(Type context, Class<?> contextRawType, Class<?> supertype) {
|
|
||||||
if (!supertype.isAssignableFrom(contextRawType)) throw new IllegalArgumentException();
|
|
||||||
return resolve(
|
|
||||||
getGenericSupertype(context, contextRawType, supertype), context, contextRawType);
|
|
||||||
}
|
|
||||||
|
|
||||||
static Type getGenericSuperclass(Type type) {
|
|
||||||
Class<?> rawType = Types.getRawType(type);
|
|
||||||
return resolve(rawType.getGenericSuperclass(), type, rawType);
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Returns the element type of {@code type} if it is an array type, or null if it is not an array
|
|
||||||
* type.
|
|
||||||
*/
|
|
||||||
static Type arrayComponentType(Type type) {
|
|
||||||
if (type instanceof GenericArrayType) {
|
|
||||||
return ((GenericArrayType) type).getGenericComponentType();
|
|
||||||
} else if (type instanceof Class) {
|
|
||||||
return ((Class<?>) type).getComponentType();
|
|
||||||
} else {
|
|
||||||
return null;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
352
moshi/src/main/java/com/squareup/moshi/Types.kt
Normal file
352
moshi/src/main/java/com/squareup/moshi/Types.kt
Normal file
@@ -0,0 +1,352 @@
|
|||||||
|
/*
|
||||||
|
* Copyright (C) 2008 Google Inc.
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*/
|
||||||
|
package com.squareup.moshi
|
||||||
|
|
||||||
|
import com.squareup.moshi.internal.EMPTY_TYPE_ARRAY
|
||||||
|
import com.squareup.moshi.internal.GenericArrayTypeImpl
|
||||||
|
import com.squareup.moshi.internal.ParameterizedTypeImpl
|
||||||
|
import com.squareup.moshi.internal.WildcardTypeImpl
|
||||||
|
import com.squareup.moshi.internal.getGenericSupertype
|
||||||
|
import com.squareup.moshi.internal.resolve
|
||||||
|
import java.lang.reflect.GenericArrayType
|
||||||
|
import java.lang.reflect.ParameterizedType
|
||||||
|
import java.lang.reflect.Proxy
|
||||||
|
import java.lang.reflect.Type
|
||||||
|
import java.lang.reflect.TypeVariable
|
||||||
|
import java.lang.reflect.WildcardType
|
||||||
|
import java.util.Collections
|
||||||
|
import java.util.Properties
|
||||||
|
import javax.annotation.CheckReturnValue
|
||||||
|
|
||||||
|
/** Factory methods for types. */
|
||||||
|
@CheckReturnValue
|
||||||
|
public object Types {
|
||||||
|
/**
|
||||||
|
* Resolves the generated [JsonAdapter] fully qualified class name for a given [clazz]. This is the same lookup logic
|
||||||
|
* used by both the Moshi code generation as well as lookup for any JsonClass-annotated classes. This can be useful
|
||||||
|
* if generating your own JsonAdapters without using Moshi's first party code gen.
|
||||||
|
*
|
||||||
|
* @param clazz the class to calculate a generated JsonAdapter name for.
|
||||||
|
* @return the resolved fully qualified class name to the expected generated JsonAdapter class.
|
||||||
|
* Note that this name will always be a top-level class name and not a nested class.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun generatedJsonAdapterName(clazz: Class<*>): String {
|
||||||
|
if (clazz.getAnnotation(JsonClass::class.java) == null) {
|
||||||
|
throw IllegalArgumentException("Class does not have a JsonClass annotation: $clazz")
|
||||||
|
}
|
||||||
|
return generatedJsonAdapterName(clazz.name)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Resolves the generated [JsonAdapter] fully qualified class name for a given [ ] `className`. This is the same lookup logic used by both
|
||||||
|
* the Moshi code generation as well as lookup for any JsonClass-annotated classes. This can be
|
||||||
|
* useful if generating your own JsonAdapters without using Moshi's first party code gen.
|
||||||
|
*
|
||||||
|
* @param className the fully qualified class to calculate a generated JsonAdapter name for.
|
||||||
|
* @return the resolved fully qualified class name to the expected generated JsonAdapter class.
|
||||||
|
* Note that this name will always be a top-level class name and not a nested class.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun generatedJsonAdapterName(className: String): String {
|
||||||
|
return className.replace("$", "_") + "JsonAdapter"
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Checks if `annotations` contains `jsonQualifier`. Returns the subset of `annotations` without `jsonQualifier`, or null if `annotations` does not contain
|
||||||
|
* `jsonQualifier`.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun nextAnnotations(
|
||||||
|
annotations: Set<Annotation>,
|
||||||
|
jsonQualifier: Class<out Annotation?>
|
||||||
|
): Set<Annotation>? {
|
||||||
|
require(jsonQualifier.isAnnotationPresent(JsonQualifier::class.java)) {
|
||||||
|
"$jsonQualifier is not a JsonQualifier."
|
||||||
|
}
|
||||||
|
if (annotations.isEmpty()) {
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
for (annotation in annotations) {
|
||||||
|
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
|
||||||
|
if ((jsonQualifier == (annotation as java.lang.annotation.Annotation).annotationType())) {
|
||||||
|
val delegateAnnotations = LinkedHashSet(annotations)
|
||||||
|
delegateAnnotations.remove(annotation)
|
||||||
|
return Collections.unmodifiableSet(delegateAnnotations)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns a new parameterized type, applying `typeArguments` to `rawType`. Use this
|
||||||
|
* method if `rawType` is not enclosed in another type.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun newParameterizedType(rawType: Type, vararg typeArguments: Type): ParameterizedType {
|
||||||
|
require(typeArguments.isNotEmpty()) {
|
||||||
|
"Missing type arguments for $rawType"
|
||||||
|
}
|
||||||
|
return ParameterizedTypeImpl(null, rawType, *typeArguments)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns a new parameterized type, applying `typeArguments` to `rawType`. Use this
|
||||||
|
* method if `rawType` is enclosed in `ownerType`.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun newParameterizedTypeWithOwner(
|
||||||
|
ownerType: Type?,
|
||||||
|
rawType: Type,
|
||||||
|
vararg typeArguments: Type
|
||||||
|
): ParameterizedType {
|
||||||
|
require(typeArguments.isNotEmpty()) {
|
||||||
|
"Missing type arguments for $rawType"
|
||||||
|
}
|
||||||
|
return ParameterizedTypeImpl(ownerType, rawType, *typeArguments)
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Returns an array type whose elements are all instances of `componentType`. */
|
||||||
|
@JvmStatic
|
||||||
|
public fun arrayOf(componentType: Type): GenericArrayType {
|
||||||
|
return GenericArrayTypeImpl(componentType)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns a type that represents an unknown type that extends `bound`. For example, if
|
||||||
|
* `bound` is `CharSequence.class`, this returns `? extends CharSequence`. If
|
||||||
|
* `bound` is `Object.class`, this returns `?`, which is shorthand for `?
|
||||||
|
* extends Object`.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun subtypeOf(bound: Type): WildcardType {
|
||||||
|
val upperBounds = if (bound is WildcardType) {
|
||||||
|
bound.upperBounds
|
||||||
|
} else {
|
||||||
|
arrayOf<Type>(bound)
|
||||||
|
}
|
||||||
|
return WildcardTypeImpl(upperBounds, EMPTY_TYPE_ARRAY)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns a type that represents an unknown supertype of `bound`. For example, if `bound` is `String.class`, this returns `? super String`.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun supertypeOf(bound: Type): WildcardType {
|
||||||
|
val lowerBounds = if (bound is WildcardType) {
|
||||||
|
bound.lowerBounds
|
||||||
|
} else {
|
||||||
|
arrayOf<Type>(bound)
|
||||||
|
}
|
||||||
|
return WildcardTypeImpl(arrayOf<Type>(Any::class.java), lowerBounds)
|
||||||
|
}
|
||||||
|
|
||||||
|
@JvmStatic
|
||||||
|
public fun getRawType(type: Type?): Class<*> {
|
||||||
|
return when (type) {
|
||||||
|
is Class<*> -> {
|
||||||
|
// type is a normal class.
|
||||||
|
type
|
||||||
|
}
|
||||||
|
is ParameterizedType -> {
|
||||||
|
// I'm not exactly sure why getRawType() returns Type instead of Class. Neal isn't either but
|
||||||
|
// suspects some pathological case related to nested classes exists.
|
||||||
|
val rawType = type.rawType
|
||||||
|
rawType as Class<*>
|
||||||
|
}
|
||||||
|
is GenericArrayType -> {
|
||||||
|
val componentType = type.genericComponentType
|
||||||
|
java.lang.reflect.Array.newInstance(getRawType(componentType), 0).javaClass
|
||||||
|
}
|
||||||
|
is TypeVariable<*> -> {
|
||||||
|
// We could use the variable's bounds, but that won't work if there are multiple. having a raw
|
||||||
|
// type that's more general than necessary is okay.
|
||||||
|
Any::class.java
|
||||||
|
}
|
||||||
|
is WildcardType -> getRawType(type.upperBounds[0])
|
||||||
|
else -> {
|
||||||
|
val className = if (type == null) "null" else type.javaClass.name
|
||||||
|
throw IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <$type> is of type $className")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the element type of this collection type.
|
||||||
|
*
|
||||||
|
* @throws IllegalArgumentException if this type is not a collection.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun collectionElementType(context: Type, contextRawType: Class<*>): Type {
|
||||||
|
var collectionType: Type? = getSupertype(context, contextRawType, MutableCollection::class.java)
|
||||||
|
if (collectionType is WildcardType) {
|
||||||
|
collectionType = collectionType.upperBounds[0]
|
||||||
|
}
|
||||||
|
return if (collectionType is ParameterizedType) {
|
||||||
|
collectionType.actualTypeArguments[0]
|
||||||
|
} else Any::class.java
|
||||||
|
}
|
||||||
|
|
||||||
|
/** Returns true if `a` and `b` are equal. */
|
||||||
|
@JvmStatic
|
||||||
|
public fun equals(a: Type?, b: Type?): Boolean {
|
||||||
|
if (a === b) {
|
||||||
|
return true // Also handles (a == null && b == null).
|
||||||
|
}
|
||||||
|
// This isn't a supported type.
|
||||||
|
when (a) {
|
||||||
|
is Class<*> -> {
|
||||||
|
return if (b is GenericArrayType) {
|
||||||
|
equals(a.componentType, b.genericComponentType)
|
||||||
|
} else {
|
||||||
|
a == b // Class already specifies equals().
|
||||||
|
}
|
||||||
|
}
|
||||||
|
is ParameterizedType -> {
|
||||||
|
if (b !is ParameterizedType) return false
|
||||||
|
val aTypeArguments = if (a is ParameterizedTypeImpl) a.typeArguments else a.actualTypeArguments
|
||||||
|
val bTypeArguments = if (b is ParameterizedTypeImpl) b.typeArguments else b.actualTypeArguments
|
||||||
|
return (
|
||||||
|
equals(a.ownerType, b.ownerType) &&
|
||||||
|
(a.rawType == b.rawType) && aTypeArguments.contentEquals(bTypeArguments)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
is GenericArrayType -> {
|
||||||
|
if (b is Class<*>) {
|
||||||
|
return equals(b.componentType, a.genericComponentType)
|
||||||
|
}
|
||||||
|
if (b !is GenericArrayType) return false
|
||||||
|
return equals(a.genericComponentType, b.genericComponentType)
|
||||||
|
}
|
||||||
|
is WildcardType -> {
|
||||||
|
if (b !is WildcardType) return false
|
||||||
|
return (a.upperBounds.contentEquals(b.upperBounds) && a.lowerBounds.contentEquals(b.lowerBounds))
|
||||||
|
}
|
||||||
|
is TypeVariable<*> -> {
|
||||||
|
if (b !is TypeVariable<*>) return false
|
||||||
|
return (a.genericDeclaration === b.genericDeclaration && (a.name == b.name))
|
||||||
|
}
|
||||||
|
else -> return false // This isn't a supported type.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @param clazz the target class to read the `fieldName` field annotations from.
|
||||||
|
* @param fieldName the target field name on `clazz`.
|
||||||
|
* @return a set of [JsonQualifier]-annotated [Annotation] instances retrieved from
|
||||||
|
* the targeted field. Can be empty if none are found.
|
||||||
|
*/
|
||||||
|
@Deprecated("This is no longer needed in Kotlin 1.6.0 (which has direct annotation instantiation) and is obsolete.")
|
||||||
|
@JvmStatic
|
||||||
|
public fun getFieldJsonQualifierAnnotations(
|
||||||
|
clazz: Class<*>,
|
||||||
|
fieldName: String
|
||||||
|
): Set<Annotation> {
|
||||||
|
try {
|
||||||
|
val field = clazz.getDeclaredField(fieldName)
|
||||||
|
field.isAccessible = true
|
||||||
|
val fieldAnnotations = field.declaredAnnotations
|
||||||
|
val annotations: MutableSet<Annotation> = LinkedHashSet(fieldAnnotations.size)
|
||||||
|
for (annotation in fieldAnnotations) {
|
||||||
|
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
|
||||||
|
if ((annotation as java.lang.annotation.Annotation).annotationType()
|
||||||
|
.isAnnotationPresent(JsonQualifier::class.java)
|
||||||
|
) {
|
||||||
|
annotations.add(annotation)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return Collections.unmodifiableSet(annotations)
|
||||||
|
} catch (e: NoSuchFieldException) {
|
||||||
|
throw IllegalArgumentException(
|
||||||
|
"Could not access field " + fieldName + " on class " + clazz.canonicalName, e
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@JvmStatic
|
||||||
|
public fun <T : Annotation?> createJsonQualifierImplementation(annotationType: Class<T>): T {
|
||||||
|
require(annotationType.isAnnotation) {
|
||||||
|
"$annotationType must be an annotation."
|
||||||
|
}
|
||||||
|
require(annotationType.isAnnotationPresent(JsonQualifier::class.java)) {
|
||||||
|
"$annotationType must have @JsonQualifier."
|
||||||
|
}
|
||||||
|
require(annotationType.declaredMethods.isEmpty()) {
|
||||||
|
"$annotationType must not declare methods."
|
||||||
|
}
|
||||||
|
@Suppress("UNCHECKED_CAST")
|
||||||
|
return Proxy.newProxyInstance(
|
||||||
|
annotationType.classLoader, arrayOf<Class<*>>(annotationType)
|
||||||
|
) { proxy, method, args ->
|
||||||
|
when (method.name) {
|
||||||
|
"annotationType" -> annotationType
|
||||||
|
"equals" -> {
|
||||||
|
val o = args[0]
|
||||||
|
annotationType.isInstance(o)
|
||||||
|
}
|
||||||
|
"hashCode" -> 0
|
||||||
|
"toString" -> "@" + annotationType.name + "()"
|
||||||
|
else -> method.invoke(proxy, *args)
|
||||||
|
}
|
||||||
|
} as T
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns a two element array containing this map's key and value types in positions 0 and 1
|
||||||
|
* respectively.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun mapKeyAndValueTypes(context: Type, contextRawType: Class<*>): Array<Type> {
|
||||||
|
// Work around a problem with the declaration of java.util.Properties. That class should extend
|
||||||
|
// Hashtable<String, String>, but it's declared to extend Hashtable<Object, Object>.
|
||||||
|
if (context === Properties::class.java) return arrayOf(String::class.java, String::class.java)
|
||||||
|
val mapType = getSupertype(context, contextRawType, MutableMap::class.java)
|
||||||
|
if (mapType is ParameterizedType) {
|
||||||
|
return mapType.actualTypeArguments
|
||||||
|
}
|
||||||
|
return arrayOf(Any::class.java, Any::class.java)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the generic form of `supertype`. For example, if this is `ArrayList<String>`, this returns `Iterable<String>` given the input `Iterable.class`.
|
||||||
|
*
|
||||||
|
* @param supertype a superclass of, or interface implemented by, this.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun getSupertype(context: Type, contextRawType: Class<*>, supertype: Class<*>): Type {
|
||||||
|
if (!supertype.isAssignableFrom(contextRawType)) throw IllegalArgumentException()
|
||||||
|
return getGenericSupertype(context, contextRawType, supertype).resolve((context), (contextRawType))
|
||||||
|
}
|
||||||
|
|
||||||
|
@JvmStatic
|
||||||
|
public fun getGenericSuperclass(type: Type): Type {
|
||||||
|
val rawType = getRawType(type)
|
||||||
|
return rawType.genericSuperclass.resolve(type, rawType)
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Returns the element type of `type` if it is an array type, or null if it is not an array
|
||||||
|
* type.
|
||||||
|
*/
|
||||||
|
@JvmStatic
|
||||||
|
public fun arrayComponentType(type: Type): Type? {
|
||||||
|
return when (type) {
|
||||||
|
is GenericArrayType -> type.genericComponentType
|
||||||
|
is Class<*> -> type.componentType
|
||||||
|
else -> null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user