Class ReflectionUtils


  • public class ReflectionUtils
    extends Object
    Utility class for resolution of generics during unmarshalling.
    Author:
    Roman Grigoriadi
    • Constructor Detail

      • ReflectionUtils

        public ReflectionUtils()
    • Method Detail

      • getOptionalRawType

        public static Optional<Class<?>> getOptionalRawType​(Type type)
        Get raw type by type. Only for ParametrizedTypes, GenericArrayTypes and Classes. Empty optional is returned if raw type cannot be resolved.
        Parameters:
        type - Type to get class information from, not null.
        Returns:
        Class of a type.
      • getRawType

        public static Class<?> getRawType​(Type type)
        Get raw type by type. Resolves only ParametrizedTypes, GenericArrayTypes and Classes. Exception is thrown if raw type cannot be resolved.
        Parameters:
        type - Type to get class information from, not null.
        Returns:
        Class of a raw type.
      • resolveRawType

        public static Class<?> resolveRawType​(RuntimeTypeInfo item,
                                              Type type)
        Get a raw type of any type. If type is a TypeVariable recursively search AbstractItem for resolution of typevar. If type is a WildcardType find most specific upper / lower bound, which can be used. If most specific bound is a TypeVariable, perform typevar resolution.
        Parameters:
        item - item containing wrapper class of a type field, not null.
        type - type to resolve, typically field type or generic bound, not null.
        Returns:
        resolved raw class
      • resolveType

        public static Type resolveType​(RuntimeTypeInfo item,
                                       Type type)
        Resolve a type by item. If type is a TypeVariable recursively search AbstractItem for resolution of typevar. If type is a WildcardType find most specific upper / lower bound, which can be used. If most specific bound is a TypeVariable, perform typevar resolution.
        Parameters:
        item - item containing wrapper class of a type field, not null.
        type - type to resolve, typically field type or generic bound, not null.
        Returns:
        resolved type
      • resolveItemVariableType

        public static Type resolveItemVariableType​(RuntimeTypeInfo item,
                                                   TypeVariable<?> typeVariable)
        Resolve a bounded type variable type by its wrapper types. Resolution could be done only if a compile time generic information is provided, either: by generic field or subclass of a generic class.
        Parameters:
        item - item to search "runtime" generic type of a TypeVariable.
        typeVariable - type to search in item for, not null.
        Returns:
        Type of a generic "runtime" bound, not null.
      • resolveTypeArguments

        public static Type resolveTypeArguments​(ParameterizedType typeToResolve,
                                                Type typeToSearch)
        Resolves TypeVariable arguments of generic types.
        Parameters:
        typeToResolve - type to resolve
        typeToSearch - type to search
        Returns:
        resolved type
      • createNoArgConstructorInstance

        public static <T> T createNoArgConstructorInstance​(Class<T> clazz)
        Search for no argument constructor of a class and create instance.
        Type Parameters:
        T - type of instance
        Parameters:
        clazz - not null
        Returns:
        instance
      • findParameterizedType

        public static ParameterizedType findParameterizedType​(Class<?> classToSearch,
                                                              Class<?> parameterizedInterface)
        For generic adapters like:

        interface ContainerAdapter<T> extends JsonbAdapter<Box<T>, Crate<T>>...; class IntegerBoxToCrateAdapter implements ContainerAdapter<Integer>...;

        We need to find a JsonbAdapter class which will hold basic generic type arguments, and resolve them if they are TypeVariables from there.
        Parameters:
        classToSearch - class to resolve parameterized interface
        parameterizedInterface - interface to search
        Returns:
        type of JsonbAdapter
      • isResolvedType

        public static boolean isResolvedType​(Type type)
        Check if type needs resolution. If type is a class or a parametrized type with all type arguments as classes than it is considered resolved. If any of types is type variable or wildcard type is not resolved.
        Parameters:
        type - Type to check.
        Returns:
        True if resolved