ru.vyarus.java.generics.resolver.util

Class TypeUtils

java.lang.Object

ru.vyarus.java.generics.resolver.util.TypeUtils

public final class TypeUtils
extends java.lang.Object

Generic-agnostic type operations.

Since:

13.05.2018

Method Summary

Modifier and Type	Method and Description
static java.lang.reflect.Type	getMoreSpecificType(java.lang.reflect.Type one, java.lang.reflect.Type two) Not resolved type variables are resolved to Object.
static java.lang.reflect.Type	getOuter(java.lang.reflect.Type type) May return ParameterizedType if incoming type contains owner declaration like Outer<String>.Inner field (field.getGenericType() will contain outer generic).
static boolean	isAssignable(java.lang.reflect.Type what, java.lang.reflect.Type toType) Checks if type could be casted to type.
static boolean	isAssignableBounds(java.lang.Class[] one, java.lang.Class[] two) Method is useful for wildcards processing.
static boolean	isCompatible(java.lang.reflect.Type one, java.lang.reflect.Type two) Check if types are compatible: types must be equal or one extend another.
static boolean	isInner(java.lang.reflect.Type type) class Owner<T> { class Inner { T field; // parent generic reference } }.
static boolean	isMoreSpecific(java.lang.reflect.Type what, java.lang.reflect.Type comparingTo) Checks if type is more specific than provided one.
static java.lang.Class<?>	wrapPrimitive(java.lang.Class<?> type)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

wrapPrimitive

public static java.lang.Class<?> wrapPrimitive(java.lang.Class<?> type)

Parameters:

type - class to wrap

Returns:

primitive wrapper class if provided class is primitive or class itself

isMoreSpecific

public static boolean isMoreSpecific(java.lang.reflect.Type what,
                                     java.lang.reflect.Type comparingTo)

Checks if type is more specific than provided one. E.g. ArrayList is more specific then List or List<Integer> is more specific then List<Object>.

Note that comparison logic did not follow all java rules (especially wildcards) as some rules are not important at runtime.

Not resolved type variables are resolved to Object. Object is considered as unknown type: everything is assignable to Object and Object is assignable to everything. List == List<Object> == List<?> == List<? super Object> == List<? extends Object>.

For lower bounded wildcards more specific wildcard contains lower bound: ? extends Number is more specific then ? extends Integer. Also, lower bounded wildcard is always more specific then Object.

Not the same as isAssignable(Type, Type). For example: isAssignable(List, List<String>) == true, but isMoreSpecific(List, List<String>) == false.

Primitive types are checked as wrappers (for example, int is more specific then Number).

Parameters:

what - type to check

comparingTo - type to compare to

Returns:

true when provided type is more specific than other type. false otherwise

Throws:

java.lang.IllegalArgumentException - when types are not compatible

See Also:

for implementation details

isAssignable

public static boolean isAssignable(java.lang.reflect.Type what,
                                   java.lang.reflect.Type toType)

Checks if type could be casted to type. Generally, method is supposed to answer: if this type could be tried to set on that place (defined by second type). Not resolved type variables are resolved to Object. Object is considered as unknown type: everything is assignable to Object and Object is assignable to everything. Note that T<String, Object> is assignable to T<String, String> as Object considered as unknown type and so could be compatible (in opposite way is also assignable as anything is assignable to Object).

Of course, actual value used instead of Object may be incompatible, but method intended only to check all available types information (if nothing stops me yet). Use exact types to get more correct result. Example usage scenario: check field type before trying to assign something with reflection.

Java wildcard rules are generally not honored because at runtime they are meaningless. List == List<Object> == List<? super Object> == List<? extends Object>. All upper bounds are used for comparison (multiple upper bounds in wildcard could be from repackaging of generic declaration T<extends A&B>. Lower bounds are taken into account as: if both have lower bound then right's type bound must be higher (? extends Number and ? extends Integer). If only left type is lower bounded wildcard then it is not assignable (except Object).

Primitive types are checked as wrappers (for example, int is more specific then Number).

Parameters:

what - type to check

toType - type to check assignability for

Returns:

true if types are equal or type is more specific, false if can't be casted or types incompatible

See Also:

for implementation details

isAssignableBounds

public static boolean isAssignableBounds(java.lang.Class[] one,
                                         java.lang.Class[] two)

Method is useful for wildcards processing. Note that it is impossibel in java to have multiple types in wildcard, but generics resolver use wildcards to store multiple generic bounds from raw resolution (T extends Something & Comparable stored as wildcard ? extends Something & Comparable). Use only when exact precision is required, otherwise you can use just first classes from both (first upper bound) as multiple bounds case is quite rare.

Bounds are assignable if one class from left bound is assignable to all types in right bound. For example,

• Number & Serializable and Number assignable
• Integer & Serializable and Number & Comparable assignable
• Integer and Number & Serializable not assignable

Object is assumed as unknown type. Object could be assigned to any type and any type could be assigned to Object. Closest analogy from java rules is no generics: for example, List without generics could be assigned anywhere (List<Integer> = List - valid java code).

No primitives expected: no special wrapping performed (as supplement method GenericsUtils.resolveUpperBounds(Type, Map) already handle primitives).

Parameters:

one - first bound

two - second bound

Returns:

true if left bound could be assigned to right bound, false otherwise

See Also:

supplement resolution method

getMoreSpecificType

public static java.lang.reflect.Type getMoreSpecificType(java.lang.reflect.Type one,
                                                         java.lang.reflect.Type two)

Not resolved type variables are resolved to Object.

Parameters:

one - first type

two - second type

Returns:

more specific type or first type is they are equal

See Also:

isMoreSpecific(Type, Type)

isCompatible

public static boolean isCompatible(java.lang.reflect.Type one,
                                   java.lang.reflect.Type two)

Check if types are compatible: types must be equal or one extend another. Object is compatible with any type.

Not resolved type variables are resolved to Object.

Primitive types are checked as wrappers (for example, int is more specific then Number).

Parameters:

one - first type

two - second type

Returns:

true if types are alignable, false otherwise

See Also:

for implementation details

isInner

public static boolean isInner(java.lang.reflect.Type type)

 class Owner<T> {
    class Inner {
      T field; // parent generic reference
    }
 }

.

Parameters:

type - class to check

Returns:

true when type is inner (requires outer class instance for creation), false otherwise

getOuter

public static java.lang.reflect.Type getOuter(java.lang.reflect.Type type)

May return ParameterizedType if incoming type contains owner declaration like Outer<String>.Inner field (field.getGenericType() will contain outer generic).

Parameters:

type - inner class (probably)

Returns:

outer type or null if type is not inner class