org.keycloak.common.util.reflections.Types クラス

org.keycloak.common.util.reflections.Types 連携図

静的公開メンバ関数
static Type	boxedType (Type type)
static Class<?>	boxedClass (Class<?> type)
static boolean	isA (Class clazz, ParameterizedType pType)
static Class	getArgumentType (ParameterizedType pType, int index)
static Class	getTemplateParameterOfInterface (Class base, Class desiredInterface)
static boolean	isCompatible (Method method, Method intfMethod)
static Method	getImplementingMethod (Class clazz, Method intfMethod)
static Class<?>	getRawType (Type type)
static Class<?>	getRawTypeNoException (Type type)
static Class<?>	getTypeArgument (Type genericType)
static Class	getCollectionBaseType (Class type, Type genericType)
static Class	getMapKeyType (Type genericType)
static Class	getMapValueType (Type genericType)
static Type	resolveTypeVariables (Class<?> root, Type type)
static Type	resolveTypeVariable (Class<?> root, TypeVariable<?> typeVariable)
static Type []	getActualTypeArgumentsOfAnInterface (Class<?> classToSearch, Class<?> interfaceToFind)
static Type []	findParameterizedTypes (Class<?> root, Class<?> searchedFor)
static Type []	findClassParameterizedTypes (Class<?> root, ParameterizedType rootType, Class<?> searchedForClass)
static Type []	findInterfaceParameterizedTypes (Class<?> root, ParameterizedType rootType, Class<?> searchedForInterface)
static< T > boolean	supports (Class< T > type, Object object, Class<?> fromInterface)

非公開メンバ関数
	Types ()

静的非公開メンバ関数
static Object	searchForInterfaceTemplateParameter (Class base, Class desiredInterface)
static Map< String, Type >	populateParameterizedMap (Class<?> root, ParameterizedType rootType)
static Type []	recurseSuperclassForInterface (Class<?> searchedForInterface, Map< String, Type > typeVarMap, Type genericSub, Class<?> sub)
static Type []	extractTypeVariables (Map< String, Type > typeVarMap, Type[] types)
static Type []	extractTypes (Map< String, Type > typeVarMap, Type genericSub)

静的非公開変数類
static final Type []	EMPTY_TYPE_ARRAY = {}

詳解

Utility class for Types

構築子と解体子

Types()

org.keycloak.common.util.reflections.Types.Types ( )

inlineprivate

                    {

    }

関数詳解

boxedClass()

static Class<?> org.keycloak.common.util.reflections.Types.boxedClass ( Class<?>  type )

inlinestatic

                                                     {
        if (!type.isPrimitive()) {
            return type;
        } else if (type.equals(Boolean.TYPE)) {
            return Boolean.class;
        } else if (type.equals(Character.TYPE)) {
            return Character.class;
        } else if (type.equals(Byte.TYPE)) {
            return Byte.class;
        } else if (type.equals(Short.TYPE)) {
            return Short.class;
        } else if (type.equals(Integer.TYPE)) {
            return Integer.class;
        } else if (type.equals(Long.TYPE)) {
            return Long.class;
        } else if (type.equals(Float.TYPE)) {
            return Float.class;
        } else if (type.equals(Double.TYPE)) {
            return Double.class;
        } else if (type.equals(Void.TYPE)) {
            return Void.class;
        } else {
            // Vagaries of if/else statement, can't be reached ;-)
            return type;
        }
    }

boxedType()

static Type org.keycloak.common.util.reflections.Types.boxedType ( Type  type )

inlinestatic

Gets the boxed type of a class

引数

type

The type

戻り値

The boxed type

                                            {
        if (type instanceof Class<?>) {
            return boxedClass((Class<?>) type);
        } else {
            return type;
        }
    }

extractTypes()

static Type [] org.keycloak.common.util.reflections.Types.extractTypes ( Map< String, Type >  typeVarMap, Type  genericSub  )

inlinestaticprivate

    {
        if (genericSub instanceof ParameterizedType)
        {
            ParameterizedType param = (ParameterizedType) genericSub;
            Type[] types = param.getActualTypeArguments();
            Type[] returnTypes = new Type[types.length];
            System.arraycopy(types, 0, returnTypes, 0, types.length);
            extractTypeVariables(typeVarMap, returnTypes);
            return returnTypes;
        }
        else
        {
            return EMPTY_TYPE_ARRAY;
        }
    }

extractTypeVariables()

static Type [] org.keycloak.common.util.reflections.Types.extractTypeVariables ( Map< String, Type >  typeVarMap, Type []  types  )

inlinestaticprivate

    {
        for (int j = 0; j < types.length; j++)
        {
            if (types[j] instanceof TypeVariable)
            {
                TypeVariable tv = (TypeVariable) types[j];
                types[j] = typeVarMap.get(tv.getName());
            }
            else
            {
                types[j] = types[j];
            }
        }
        return types;
    }

findClassParameterizedTypes()

static Type [] org.keycloak.common.util.reflections.Types.findClassParameterizedTypes ( Class<?>  root, ParameterizedType  rootType, Class<?>  searchedForClass  )

inlinestatic

    {
        if (Object.class.equals(root)) return null;

        Map<String, Type> typeVarMap = populateParameterizedMap(root, rootType);

        Class<?> superclass = root.getSuperclass();
        Type genericSuper = root.getGenericSuperclass();

        if (superclass.equals(searchedForClass))
        {
            return extractTypes(typeVarMap, genericSuper);
        }


        if (genericSuper instanceof ParameterizedType)
        {
            ParameterizedType intfParam = (ParameterizedType) genericSuper;
            Type[] types = findClassParameterizedTypes(superclass, intfParam, searchedForClass);
            if (types != null)
            {
                return extractTypeVariables(typeVarMap, types);
            }
        }
        else
        {
            Type[] types = findClassParameterizedTypes(superclass, null, searchedForClass);
            if (types != null)
            {
                return types;
            }
        }
        return null;
    }

findInterfaceParameterizedTypes()

static Type [] org.keycloak.common.util.reflections.Types.findInterfaceParameterizedTypes ( Class<?>  root, ParameterizedType  rootType, Class<?>  searchedForInterface  )

inlinestatic

    {
        Map<String, Type> typeVarMap = populateParameterizedMap(root, rootType);

        for (int i = 0; i < root.getInterfaces().length; i++)
        {
            Class<?> sub = root.getInterfaces()[i];
            Type genericSub = root.getGenericInterfaces()[i];
            if (sub.equals(searchedForInterface))
            {
                return extractTypes(typeVarMap, genericSub);
            }
        }

        for (int i = 0; i < root.getInterfaces().length; i++)
        {
            Type genericSub = root.getGenericInterfaces()[i];
            Class<?> sub = root.getInterfaces()[i];

            Type[] types = recurseSuperclassForInterface(searchedForInterface, typeVarMap, genericSub, sub);
            if (types != null) return types;
        }
        if (root.isInterface()) return null;

        Class<?> superclass = root.getSuperclass();
        Type genericSuper = root.getGenericSuperclass();


        return recurseSuperclassForInterface(searchedForInterface, typeVarMap, genericSuper, superclass);
    }

findParameterizedTypes()

static Type [] org.keycloak.common.util.reflections.Types.findParameterizedTypes ( Class<?>  root, Class<?>  searchedFor  )

inlinestatic

Search for the given interface or class within the root's class/interface hierarchy. If the searched for class/interface is a generic return an array of real types that fill it out.

引数

root
searchedFor

戻り値

    {
        if (searchedFor.isInterface())
        {
            return findInterfaceParameterizedTypes(root, null, searchedFor);
        }
        return findClassParameterizedTypes(root, null, searchedFor);
    }

getActualTypeArgumentsOfAnInterface()

static Type [] org.keycloak.common.util.reflections.Types.getActualTypeArgumentsOfAnInterface ( Class<?>  classToSearch, Class<?>  interfaceToFind  )

inlinestatic

Given a class and an interfaces, go through the class hierarchy to find the interface and return its type arguments.

引数

classToSearch
interfaceToFind

戻り値

type arguments of the interface

    {
        Type[] types = findParameterizedTypes(classToSearch, interfaceToFind);
        if (types == null) throw new RuntimeException("Unable to find type arguments");
        return types;
    }

getArgumentType()

static Class org.keycloak.common.util.reflections.Types.getArgumentType ( ParameterizedType  pType, int  index  )

inlinestatic

Gets the index-th type argument.

    {
        return (Class) pType.getActualTypeArguments()[index];
    }

getCollectionBaseType()

static Class org.keycloak.common.util.reflections.Types.getCollectionBaseType ( Class  type, Type  genericType  )

inlinestatic

    {
        if (genericType instanceof ParameterizedType)
        {
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            Type componentGenericType = parameterizedType.getActualTypeArguments()[0];
            return getRawType(componentGenericType);
        }
        else if (genericType instanceof GenericArrayType)
        {
            final GenericArrayType genericArrayType = (GenericArrayType) genericType;
            Type componentGenericType = genericArrayType.getGenericComponentType();
            return getRawType(componentGenericType);
        }
        else if (type.isArray())
        {
            return type.getComponentType();
        }
        return null;
    }

getImplementingMethod()

static Method org.keycloak.common.util.reflections.Types.getImplementingMethod ( Class  clazz, Method  intfMethod  )

inlinestatic

Given a method and a root class, find the actual method declared in the root that implements the method.

引数

clazz
intfMethod

戻り値

    {
        Class<?> declaringClass = intfMethod.getDeclaringClass();
        if (declaringClass.equals(clazz)) return intfMethod;

        Class[] paramTypes = intfMethod.getParameterTypes();

        if (declaringClass.getTypeParameters().length > 0 && paramTypes.length > 0)
        {
            Type[] intfTypes = findParameterizedTypes(clazz, declaringClass);
            Map<String, Type> typeVarMap = new HashMap<String, Type>();
            TypeVariable<? extends Class<?>>[] vars = declaringClass.getTypeParameters();
            for (int i = 0; i < vars.length; i++)
            {
                if (intfTypes != null && i < intfTypes.length)
                {
                    typeVarMap.put(vars[i].getName(), intfTypes[i]);
                }
                else
                {
                    // Interface type parameters may not have been filled out
                    typeVarMap.put(vars[i].getName(), vars[i].getGenericDeclaration());
                }
            }
            Type[] paramGenericTypes = intfMethod.getGenericParameterTypes();
            paramTypes = new Class[paramTypes.length];

            for (int i = 0; i < paramTypes.length; i++)
            {
                if (paramGenericTypes[i] instanceof TypeVariable)
                {
                    TypeVariable tv = (TypeVariable)paramGenericTypes[i];
                    Type t = typeVarMap.get(tv.getName());
                    if (t == null)
                    {
                        throw new RuntimeException("Unable to resolve type variable");
                    }
                    paramTypes[i] = getRawType(t);
                }
                else
                {
                    paramTypes[i] = getRawType(paramGenericTypes[i]);
                }
            }

        }

        try
        {
            return clazz.getMethod(intfMethod.getName(), paramTypes);
        }
        catch (NoSuchMethodException e)
        {
        }

        try
        {
            Method tmp = clazz.getMethod(intfMethod.getName(), intfMethod.getParameterTypes());
            return tmp;
        }
        catch (NoSuchMethodException e)
        {

        }
        return intfMethod;
    }

getMapKeyType()

static Class org.keycloak.common.util.reflections.Types.getMapKeyType ( Type  genericType )

inlinestatic

    {
        if (genericType instanceof ParameterizedType)
        {
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            Type componentGenericType = parameterizedType.getActualTypeArguments()[0];
            return getRawType(componentGenericType);
        }
        return null;
    }

getMapValueType()

static Class org.keycloak.common.util.reflections.Types.getMapValueType ( Type  genericType )

inlinestatic

    {
        if (genericType instanceof ParameterizedType)
        {
            ParameterizedType parameterizedType = (ParameterizedType) genericType;
            Type componentGenericType = parameterizedType.getActualTypeArguments()[1];
            return getRawType(componentGenericType);
        }
        return null;
    }

getRawType()

static Class<?> org.keycloak.common.util.reflections.Types.getRawType ( Type  type )

inlinestatic

    {
        if (type instanceof Class<?>)
        {
            // type is a normal class.
            return (Class<?>) type;

        }
        else if (type instanceof ParameterizedType)
        {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type rawType = parameterizedType.getRawType();
            return (Class<?>) rawType;
        }
        else if (type instanceof GenericArrayType)
        {
            final GenericArrayType genericArrayType = (GenericArrayType) type;
            final Class<?> componentRawType = getRawType(genericArrayType.getGenericComponentType());
            return Array.newInstance(componentRawType, 0).getClass();
        }
        else if (type instanceof TypeVariable)
        {
            final TypeVariable typeVar = (TypeVariable) type;
            if (typeVar.getBounds() != null && typeVar.getBounds().length > 0)
            {
                return getRawType(typeVar.getBounds()[0]);
            }
        }
        throw new RuntimeException("unable to determine base class");
    }

getRawTypeNoException()

static Class<?> org.keycloak.common.util.reflections.Types.getRawTypeNoException ( Type  type )

inlinestatic

    {
        if (type instanceof Class<?>)
        {
            // type is a normal class.
            return (Class<?>) type;

        }
        else if (type instanceof ParameterizedType)
        {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type rawType = parameterizedType.getRawType();
            return (Class<?>) rawType;
        }
        else if (type instanceof GenericArrayType)
        {
            final GenericArrayType genericArrayType = (GenericArrayType) type;
            final Class<?> componentRawType = getRawType(genericArrayType.getGenericComponentType());
            return Array.newInstance(componentRawType, 0).getClass();
        }
        return null;
    }

getTemplateParameterOfInterface()

static Class org.keycloak.common.util.reflections.Types.getTemplateParameterOfInterface ( Class  base, Class  desiredInterface  )

inlinestatic

    {
        Object rtn = searchForInterfaceTemplateParameter(base, desiredInterface);
        if (rtn != null && rtn instanceof Class) return (Class) rtn;
        return null;
    }

getTypeArgument()

static Class<?> org.keycloak.common.util.reflections.Types.getTypeArgument ( Type  genericType )

inlinestatic

Returns the type argument from a parameterized type

引数

genericType

戻り値

null if there is no type parameter

    {
        if (!(genericType instanceof ParameterizedType)) return null;
        ParameterizedType parameterizedType = (ParameterizedType) genericType;
        Class<?> typeArg = (Class<?>) parameterizedType.getActualTypeArguments()[0];
        return typeArg;
    }

isA()

static boolean org.keycloak.common.util.reflections.Types.isA ( Class  clazz, ParameterizedType  pType  )

inlinestatic

Is the genericType of a certain class?

    {
        return clazz.isAssignableFrom((Class) pType.getRawType());
    }

isCompatible()

static boolean org.keycloak.common.util.reflections.Types.isCompatible ( Method  method, Method  intfMethod  )

inlinestatic

See if the two methods are compatible, that is they have the same relative signature

引数

method
intfMethod

戻り値

    {
        if (method == intfMethod) return true;

        if (!method.getName().equals(intfMethod.getName())) return false;
        if (method.getParameterTypes().length != intfMethod.getParameterTypes().length) return false;

        for (int i = 0; i < method.getParameterTypes().length; i++)
        {
            Class rootParam = method.getParameterTypes()[i];
            Class intfParam = intfMethod.getParameterTypes()[i];
            if (!intfParam.isAssignableFrom(rootParam)) return false;
        }
        return true;
    }

populateParameterizedMap()

static Map<String, Type> org.keycloak.common.util.reflections.Types.populateParameterizedMap ( Class<?>  root, ParameterizedType  rootType  )

inlinestaticprivate

    {
        Map<String, Type> typeVarMap = new HashMap<String, Type>();
        if (rootType != null)
        {
            TypeVariable<? extends Class<?>>[] vars = root.getTypeParameters();
            for (int i = 0; i < vars.length; i++)
            {
                typeVarMap.put(vars[i].getName(), rootType.getActualTypeArguments()[i]);
            }
        }
        return typeVarMap;
    }

recurseSuperclassForInterface()

static Type [] org.keycloak.common.util.reflections.Types.recurseSuperclassForInterface ( Class<?>  searchedForInterface, Map< String, Type >  typeVarMap, Type  genericSub, Class<?>  sub  )

inlinestaticprivate

    {
        if (genericSub instanceof ParameterizedType)
        {
            ParameterizedType intfParam = (ParameterizedType) genericSub;
            Type[] types = findInterfaceParameterizedTypes(sub, intfParam, searchedForInterface);
            if (types != null)
            {
                return extractTypeVariables(typeVarMap, types);
            }
        }
        else
        {
            Type[] types = findInterfaceParameterizedTypes(sub, null, searchedForInterface);
            if (types != null)
            {
                return types;
            }
        }
        return null;
    }

resolveTypeVariable()

static Type org.keycloak.common.util.reflections.Types.resolveTypeVariable ( Class<?>  root, TypeVariable<?>  typeVariable  )

inlinestatic

Finds an actual value of a type variable. The method looks in a class hierarchy for a class defining the variable and returns the value if present.

引数

root
typeVariable

戻り値

actual type of the type variable

    {
        if (typeVariable.getGenericDeclaration() instanceof Class<?>)
        {
            Class<?> classDeclaringTypeVariable = (Class<?>) typeVariable.getGenericDeclaration();
            Type[] types = findParameterizedTypes(root, classDeclaringTypeVariable);
            if (types == null) return  null;
            for (int i = 0; i < types.length; i++)
            {
                TypeVariable<?> tv = classDeclaringTypeVariable.getTypeParameters()[i];
                if (tv.equals(typeVariable))
                {
                    return types[i];
                }
            }
        }
        return null;
    }

resolveTypeVariables()

static Type org.keycloak.common.util.reflections.Types.resolveTypeVariables ( Class<?>  root, Type  type  )

inlinestatic

    {
        if (type instanceof TypeVariable)
        {
            Type newType = resolveTypeVariable(root, (TypeVariable)type);
            return (newType == null) ? type : newType;
        }
        else if (type instanceof ParameterizedType)
        {
            final ParameterizedType param = (ParameterizedType)type;
            final Type[] actuals = new Type[param.getActualTypeArguments().length];
            for (int i = 0; i < actuals.length; i++)
            {
                Type newType = resolveTypeVariables(root, param.getActualTypeArguments()[i]);
                actuals[i] = newType == null ? param.getActualTypeArguments()[i] : newType;
            }
            return new ParameterizedType() {
                @Override
                public Type[] getActualTypeArguments()
                {
                    return actuals;
                }

                @Override
                public Type getRawType()
                {
                    return param.getRawType();
                }

                @Override
                public Type getOwnerType()
                {
                    return param.getOwnerType();
                }
            };
        }
        else if (type instanceof GenericArrayType)
        {
            GenericArrayType arrayType = (GenericArrayType)type;
            final Type componentType = resolveTypeVariables(root, arrayType.getGenericComponentType());
            if (componentType == null) return type;
            return new GenericArrayType()
            {
                @Override
                public Type getGenericComponentType()
                {
                    return componentType;
                }
            };
        }
        else
        {
            return type;
        }
    }

searchForInterfaceTemplateParameter()

static Object org.keycloak.common.util.reflections.Types.searchForInterfaceTemplateParameter ( Class  base, Class  desiredInterface  )

inlinestaticprivate

    {
        for (int i = 0; i < base.getInterfaces().length; i++)
        {
            Class intf = base.getInterfaces()[i];
            if (intf.equals(desiredInterface))
            {
                Type generic = base.getGenericInterfaces()[i];
                if (generic instanceof ParameterizedType)
                {
                    ParameterizedType p = (ParameterizedType) generic;
                    Type type = p.getActualTypeArguments()[0];
                    Class rtn = getRawTypeNoException(type);
                    if (rtn != null) return rtn;
                    return type;
                }
                else
                {
                    return null;
                }
            }
        }
        if (base.getSuperclass() == null || base.getSuperclass().equals(Object.class)) return null;
        Object rtn = searchForInterfaceTemplateParameter(base.getSuperclass(), desiredInterface);
        if (rtn == null || rtn instanceof Class) return rtn;
        if (!(rtn instanceof TypeVariable)) return null;

        String name = ((TypeVariable) rtn).getName();
        int index = -1;
        TypeVariable[] variables = base.getSuperclass().getTypeParameters();
        if (variables == null || variables.length < 1) return null;

        for (int i = 0; i < variables.length; i++)
        {
            if (variables[i].getName().equals(name)) index = i;
        }
        if (index == -1) return null;


        Type genericSuperclass = base.getGenericSuperclass();
        if (!(genericSuperclass instanceof ParameterizedType)) return null;

        ParameterizedType pt = (ParameterizedType) genericSuperclass;
        Type type = pt.getActualTypeArguments()[index];

        Class clazz = getRawTypeNoException(type);
        if (clazz != null) return clazz;
        return type;
    }

supports()

static <T> boolean org.keycloak.common.util.reflections.Types.supports ( Class< T >  type, Object  object, Class<?>  fromInterface  )

inlinestatic

Grabs the parameterized type of fromInterface that object implements and sees if it is assignable from type.

引数

type
object
fromInterface
<T>

戻り値

                                                                                             {
        Type providerType = getActualTypeArgumentsOfAnInterface(object.getClass(), fromInterface)[0];
        Class providerClass = getRawType(providerType);
        return type.isAssignableFrom(providerClass);
    }

メンバ詳解

EMPTY_TYPE_ARRAY

final Type [] org.keycloak.common.util.reflections.Types.EMPTY_TYPE_ARRAY = {}

staticprivate

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/doxygen/keycloak/src/keycloak/src/main/java/org/keycloak/common/util/reflections/Types.java