/** * 预先获取orika转换所需要的Type,避免每次转换. */ public static <E> Type<E> getType(final Class<E> rawType) { return TypeFactory.valueOf(rawType); }
public <S, D> D[] mapAsArray(D[] destination, S[] source, Class<D> destinationClass) { return mapAsArray(destination, source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass)); }
public <S, D> Set<D> mapAsSet(Iterable<S> source, Class<D> destinationClass, MappingContext context) { return mapAsSet(source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context); }
/** * Resolves the Type value of the specified raw Class type * * @param rawType * @return the resolved Type instance */ public static <E> Type<E> valueOf(final Class<E> rawType) { if (rawType == null) { return null; } else if (rawType.isAnonymousClass() && rawType.getGenericSuperclass() instanceof ParameterizedType) { ParameterizedType genericSuper = (ParameterizedType) rawType.getGenericSuperclass(); return valueOf(genericSuper); } else { return intern(rawType, new java.lang.reflect.Type[0], new HashSet<java.lang.reflect.Type>()); } }
/** * @param rawType * @param recursiveBounds * @param actualTypeArguments * @return the resolved Type instance */ private static <E> Type<E> limitedValueOf(final Class<E> rawType, Set<java.lang.reflect.Type> recursiveBounds, final java.lang.reflect.Type... actualTypeArguments) { if (rawType == null) { return null; } else if (rawType.isAnonymousClass() && rawType.getGenericSuperclass() instanceof ParameterizedType) { ParameterizedType genericSuper = (ParameterizedType) rawType.getGenericSuperclass(); return limitedValueOf(genericSuper, recursiveBounds); } else { return intern(rawType, actualTypeArguments, recursiveBounds); } }
/** * Resolve the Type value of the given raw Class type, filling the type * parameters with the provided actual type arguments * * @param rawType * @param actualTypeArguments * @return the resolved Type instance */ public static <E> Type<E> valueOf(final Class<E> rawType, final java.lang.reflect.Type... actualTypeArguments) { if (rawType == null) { return null; } else { return intern(rawType, actualTypeArguments, new HashSet<java.lang.reflect.Type>()); } }
typeResult = createType(key, rawType, convertedArguments); mapped = new WeakReference<Type<?>>(typeResult); WeakReference<Type<?>> existing = typeCache.putIfAbsent(key, mapped);
/** * Resolves the Type value of the specified raw Class type * * @param rawType * @return the resolved Type instance */ public static <E> Type<E> valueOf(final Class<E> rawType) { if (rawType == null) { return null; } else if (rawType.isAnonymousClass() && rawType.getGenericSuperclass() instanceof ParameterizedType) { ParameterizedType genericSuper = (ParameterizedType) rawType.getGenericSuperclass(); return valueOf(genericSuper); } else { return intern(rawType, new java.lang.reflect.Type[0], new HashSet<java.lang.reflect.Type>()); } }
/** * @param rawType * @param recursiveBounds * @param actualTypeArguments * @return the resolved Type instance */ public static <E> Type<E> limitedValueOf(final Class<E> rawType, Set<java.lang.reflect.Type> recursiveBounds, final java.lang.reflect.Type... actualTypeArguments) { if (rawType == null) { return null; } else if (rawType.isAnonymousClass() && rawType.getGenericSuperclass() instanceof ParameterizedType) { ParameterizedType genericSuper = (ParameterizedType) rawType.getGenericSuperclass(); return limitedValueOf(genericSuper, recursiveBounds); } else { return (Type<E>) intern(rawType, actualTypeArguments, recursiveBounds); } }
/** * Resolve the Type value of the given raw Class type, filling the type * parameters with the provided actual type arguments * * @param rawType * @param actualTypeArguments * @return the resolved Type instance */ public static <E> Type<E> valueOf(final Class<E> rawType, final java.lang.reflect.Type... actualTypeArguments) { if (rawType == null) { return null; } else { return (Type<E>) intern((Class<E>) rawType, actualTypeArguments, new HashSet<java.lang.reflect.Type>()); } }
typeResult = createType(key, rawType, convertedArguments); mapped = new WeakReference<Type<?>>(typeResult); WeakReference<Type<?>> existing = typeCache.putIfAbsent(key, mapped);
/** * Set the type * * @param type * @return */ public Builder type(final java.lang.reflect.Type type) { this.propertyType = TypeFactory.valueOf(type); return this; }
public <S, D> List<D> mapAsList(S[] source, Class<D> destinationClass) { return mapAsList(source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass)); }
public <S, D> List<D> mapAsList(Iterable<S> source, Class<D> destinationClass, MappingContext context) { return mapAsList(source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context); }
/** * Resolve the Type for the given ParameterizedType, using the provided * referenceType to resolve any unresolved actual type arguments. * * @param type * @param referenceType * @return the resolved Type instance */ @SuppressWarnings("unchecked") public static <T> Type<T> resolveValueOf(final ParameterizedType type, final Type<?> referenceType) { if (type == null) { return null; } else { java.lang.reflect.Type[] actualTypeArguments = TypeUtil.resolveActualTypeArguments(type, referenceType); return intern((Class<T>) type.getRawType(), actualTypeArguments, new HashSet<java.lang.reflect.Type>()); } }
@SuppressWarnings("unchecked") private <T> Type<Optional<T>> getOptionalTypeOf(Type<T> type) { return (Type) TypeFactory.valueOf(Optional.class, type); } }
public <S, D> List<D> mapAsList(S[] source, Class<D> destinationClass, MappingContext context) { return mapAsList(source, TypeFactory.componentTypeOf(source), TypeFactory.<D> valueOf(destinationClass), context); }
public <S, D> Set<D> mapAsSet(Iterable<S> source, Class<D> destinationClass) { return mapAsSet(source, TypeFactory.elementTypeOf(source), TypeFactory.<D> valueOf(destinationClass)); }
/** * Resolve the Type for the given ParameterizedType, using the provided * referenceType to resolve any unresolved actual type arguments. * * @param type * @param referenceType * @return the resolved Type instance */ @SuppressWarnings("unchecked") public static <T> Type<T> resolveValueOf(final ParameterizedType type, final Type<?> referenceType) { if (type == null) { return null; } else { java.lang.reflect.Type[] actualTypeArguments = TypeUtil.resolveActualTypeArguments(type, referenceType); Type<T> result = intern((Class<T>) type.getRawType(), actualTypeArguments, new HashSet<java.lang.reflect.Type>()); return result; } }
/** * @return the Type instance built by this builder */ public final Type<T> build() { return TypeFactory.valueOf(rawType, actualTypeArguments); }