org.mule.runtime.module.extension.internal.util

Class IntrospectionUtils

java.lang.Object

org.mule.runtime.module.extension.internal.util.IntrospectionUtils

public final class IntrospectionUtils
extends Object

Set of utility operations to get insights about objects and their components

Since:

3.7.0

Method Summary

Modifier and Type	Method and Description
static boolean	assignableFromAny(Class<?> type, Collection<Class<?>> matchingTypes) Determines if the given type is assignable from any of the matchingTypes
static void	checkInstantiable(Class<?> declaringClass)
static void	checkInstantiable(Class<?> declaringClass, boolean requireDefaultConstructor)
static Set<Class<?>>	collectRelativeClasses(org.mule.metadata.api.model.MetadataType type, ClassLoader extensionClassLoader) Given a MetadataType it adds all the Class that are related from that type.
static List<Class<?>>	findGenericsInSuperHierarchy(Class<?> type)
static <T extends AnnotatedElement & Member> String	getAlias(T element) Returns the Alias name of the given element.
static Optional<AnnotatedElement>	getAnnotatedElement(org.mule.runtime.api.meta.model.declaration.fluent.BaseDeclaration<?> declaration)
static List<Field>	getAnnotatedFields(Class<?> clazz, Class<? extends Annotation> annotationType)
static <T extends Annotation> T	getAnnotation(Class<?> annotatedClass, Class<T> annotationClass) Looks for the annotation in the given class.
static Collection<Method>	getApiMethods(Class<?> declaringClass)
static Optional<org.mule.runtime.api.meta.model.connection.ConnectionProviderModel>	getConnectionProviderModel(Class<? extends org.mule.runtime.api.connection.ConnectionProvider> connectionProvider, List<org.mule.runtime.api.meta.model.connection.ConnectionProviderModel> allConnectionProviders) Resolves the correspondent ConnectionProviderModel for a given ConnectionProvider instance.
static String	getContainerName(AnnotatedElement container)
static Optional<FieldSetter>	getDefaultEncodingFieldSetter(Object target) Returns a FieldSetter for a field in the target annotated DefaultEncoding (if present)
static Collection<Field>	getExposedFields(Class<?> extensionType)
static org.mule.runtime.api.meta.ExpressionSupport	getExpressionSupport(AnnotatedElement object)
static org.mule.runtime.api.meta.ExpressionSupport	getExpressionSupport(org.mule.runtime.extension.api.annotation.Expression expressionAnnotation)
static Optional<Field>	getField(Class<?> clazz, org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclaration parameterDeclaration)
static Optional<Field>	getField(Class<?> clazz, org.mule.runtime.api.meta.model.parameter.ParameterModel parameterModel)
static Optional<Field>	getField(Class<?> clazz, String name)
static Optional<Field>	getFieldByNameOrAlias(Class<?> clazz, String nameOrAlias)
static org.mule.metadata.api.model.MetadataType	getFieldMetadataType(Field field, org.mule.metadata.api.ClassTypeLoader typeLoader) Returns a MetadataType describing the given Field's type
static List<Field>	getFields(Class<?> clazz)
static List<Field>	getFieldsOfType(Class<?> introspectedType, Class fieldType)
static Set<Field>	getFieldsWithGetters(Class<?> extensionType)
static Object	getFieldValue(Object object, String fieldName) Resolves and returns the field value of an object instance
static List<org.mule.metadata.api.model.MetadataType>	getGenerics(Type type, org.mule.metadata.api.ClassTypeLoader typeLoader)
static String	getGroupModelContainerName(org.mule.runtime.api.meta.model.parameter.ParameterGroupModel groupModel)
static String	getImplementingName(org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclaration parameterDeclaration) Resolves the original name of a parameter before it was modified due to the usage of an Alias.
static String	getImplementingName(org.mule.runtime.api.meta.model.parameter.ParameterModel parameterModel) Resolves the original name of a parameter before it was modified due to the usage of an Alias.
static List<Class<?>>	getInterfaceGenerics(Class<?> type, Class<?> implementedInterface)
static String	getMemberName(org.mule.runtime.api.meta.model.EnrichableModel enrichableModel, String defaultName)
static org.mule.metadata.api.model.MetadataType	getMetadataType(Class<?> type, org.mule.metadata.api.ClassTypeLoader typeLoader) Returns a MetadataType representing the given Class type.
static org.mule.metadata.api.model.MetadataType[]	getMethodArgumentTypes(Method method, org.mule.metadata.api.ClassTypeLoader typeLoader) Returns an array of MetadataType representing each of the given Method's argument types.
static org.mule.metadata.api.model.MetadataType	getMethodReturnAttributesType(Method method, org.mule.metadata.api.ClassTypeLoader typeLoader) Returns a MetadataType representing the Result.getAttributes() that will be set after executing the given method.
static org.mule.metadata.api.model.MetadataType	getMethodReturnType(Method method, org.mule.metadata.api.ClassTypeLoader typeLoader) Returns a MetadataType representing the given Method's return type.
static Collection<Method>	getMethodsAnnotatedWith(Class<?> declaringClass, Class<? extends Annotation> annotationType) Returns all the methods in the declaringClass which are annotated with annotationType, including those declared in super classes.
static Collection<Method>	getMethodsAnnotatedWith(Class<?> declaringClass, Class<? extends Annotation> annotationType, boolean superClasses) Returns all the methods in the declaringClass which are annotated with annotationType
static org.mule.runtime.api.util.Pair<org.springframework.core.ResolvableType,org.springframework.core.ResolvableType>	getPagingProviderTypes(org.springframework.core.ResolvableType pagingProvider) Introspects a PagingProvider type and returns their generics.
static Set<Class<?>>	getParameterClasses(org.mule.runtime.api.meta.model.ExtensionModel extensionModel, ClassLoader extensionClassLoader) Traverses through all the ParameterModels of the extensionModel and returns the classes that are modeled by each parameter's Typed.getType().
static String	getSourceName(Class<? extends org.mule.runtime.extension.api.runtime.source.Source> sourceType)
static org.mule.metadata.api.model.MetadataType	getSourceReturnType(Type returnType, org.mule.metadata.api.ClassTypeLoader typeLoader) Returns the MetadataType for a source's output.
static List<Type>	getSuperClassGenerics(Class<?> type, Class<?> superClass)
static boolean	hasDefaultConstructor(Class<?> clazz)
static void	injectComponentLocation(Object target, org.mule.runtime.api.component.location.ComponentLocation componentLocation) Introspects the target object for a field of type ComponentLocation.
static void	injectDefaultEncoding(org.mule.runtime.api.meta.model.EnrichableModel model, Object target, String encoding) Sets the encoding value into the field of the target annotated DefaultEncoding if the model contains the DeclaringMemberModelProperty property and the value is not null.
static void	injectDefaultEncoding(Object target, String encoding) Sets the encoding value into the field of the target annotated DefaultEncoding (if present)
static void	injectFields(org.mule.runtime.api.meta.model.EnrichableModel model, Object target, String configName, String encoding) Sets the configName into the field of the target annotated RefName (if it's present) and does the same for the encoding and the field annotated with DefaultEncoding if the model contains the DeclaringMemberModelProperty
static void	injectFields(Object target, String configName, String encoding) Sets the configName into the field of the target annotated RefName (if it's present) and does the same for the encoding and the field annotated with DefaultEncoding.
static void	injectRefName(Object target, String configName) Introspects the target object for a field annotated with RefName.
static boolean	isInstantiable(Class<?> declaringClass)
static boolean	isInstantiable(Class<?> declaringClass, boolean requireDefaultConstructor)
static boolean	isInstantiable(org.mule.metadata.api.model.MetadataType type)
static boolean	isLifecycle(Class<?> type) Determines if the given type implements any of the lifecycle annotations
static boolean	isLiteral(org.mule.metadata.api.model.MetadataType metadataType)
static boolean	isMultiLevelMetadataKeyId(Set<Class<? extends Annotation>> annotations, org.mule.metadata.api.model.MetadataType parameterType) Given a Set of Annotation classes and a MetadataType that describes a component parameter, indicates if the parameter is considered as a multilevel MetadataKeyId
static boolean	isParameterContainer(Set<Class<? extends Annotation>> annotations, org.mule.metadata.api.model.MetadataType parameterType) Given a Set of annotation classes and a MetadataType of a component parameter, indicates if the parameter is a parameter container.
static boolean	isParameterResolver(org.mule.metadata.api.model.MetadataType metadataType)
static boolean	isRequired(AccessibleObject object)
static boolean	isRequired(org.mule.runtime.api.meta.model.parameter.ParameterModel parameterModel, boolean forceOptional)
static boolean	isTargetParameter(Set<org.mule.runtime.api.meta.model.ModelProperty> modelProperties)
static boolean	isTypedValue(org.mule.metadata.api.model.MetadataType metadataType)
static boolean	isVoid(org.mule.runtime.api.meta.model.ComponentModel componentModel)
static boolean	isVoid(Method method)
static org.mule.runtime.api.metadata.DataType	toDataType(org.mule.metadata.api.model.MetadataType metadataType) Transforms a MetadataType and generates the correspondent DataType

Methods inherited from class java.lang.Object

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

Method Detail

getMetadataType

public static org.mule.metadata.api.model.MetadataType getMetadataType(Class<?> type,
                                                                       org.mule.metadata.api.ClassTypeLoader typeLoader)

Returns a MetadataType representing the given Class type.

Parameters:

type - the Class being introspected

typeLoader - a ClassTypeLoader used to create the MetadataType

Returns:

a MetadataType

toDataType

public static org.mule.runtime.api.metadata.DataType toDataType(org.mule.metadata.api.model.MetadataType metadataType)

Transforms a MetadataType and generates the correspondent DataType

Parameters:

metadataType - to introspect a create a DataType from it.

Returns:

a DataType based on the given MetadataType

getMethodReturnType

public static org.mule.metadata.api.model.MetadataType getMethodReturnType(Method method,
                                                                           org.mule.metadata.api.ClassTypeLoader typeLoader)

Returns a MetadataType representing the given Method's return type. If the method returns an Result, then it returns the type of the first generic. If the Result type is being used in its raw form, then an AnyType will be returned.

If the method returns a collection of Result instances, then it will return an ArrayType which inner value represent a Message which payload and attributes matches the types of the Result generics.

Parameters:

method - the Method being introspected

typeLoader - a ClassTypeLoader used to create the MetadataType

Returns:

a MetadataType

Throws:

IllegalArgumentException - is method is null

getSourceReturnType

public static org.mule.metadata.api.model.MetadataType getSourceReturnType(Type returnType,
                                                                           org.mule.metadata.api.ClassTypeLoader typeLoader)

Returns the MetadataType for a source's output.

If the type is a collection of Result instances, then it will return an ArrayType which inner value represent a Message which payload and attributes matches the types of the Result generics.

Parameters:

returnType - the source output type

typeLoader - a ClassTypeLoader used to create the MetadataType

Returns:

a MetadataType

getMethodReturnAttributesType

public static org.mule.metadata.api.model.MetadataType getMethodReturnAttributesType(Method method,
                                                                                     org.mule.metadata.api.ClassTypeLoader typeLoader)

Returns a MetadataType representing the Result.getAttributes() that will be set after executing the given method.

If the method returns a Result, then it returns the type of the Attributes generic. In any other case (including raw uses of Result) it will return a VoidType

If the method returns a collection or a PagingProvider of Result, then this will return VoidType since the messages in the main output already contain an attributes for each item.

Parameters:

method - the Method being introspected

typeLoader - a ClassTypeLoader used to create the MetadataType

Returns:

a MetadataType

Throws:

IllegalArgumentException - is method is null

getGenerics

public static List<org.mule.metadata.api.model.MetadataType> getGenerics(Type type,
                                                                         org.mule.metadata.api.ClassTypeLoader typeLoader)

isLifecycle

public static boolean isLifecycle(Class<?> type)

Determines if the given type implements any of the lifecycle annotations

Parameters:

type - the class to evaluate

Returns:

whether it implements lifecycle or not

getMethodArgumentTypes

public static org.mule.metadata.api.model.MetadataType[] getMethodArgumentTypes(Method method,
                                                                                org.mule.metadata.api.ClassTypeLoader typeLoader)

Returns an array of MetadataType representing each of the given Method's argument types.

Parameters:

method - a not null Method

typeLoader - a ClassTypeLoader to be used to create the returned MetadataTypes

Returns:

an array of MetadataType matching the method's arguments. If the method doesn't take any, then the array will be empty

Throws:

IllegalArgumentException - is method is null

getFieldMetadataType

public static org.mule.metadata.api.model.MetadataType getFieldMetadataType(Field field,
                                                                            org.mule.metadata.api.ClassTypeLoader typeLoader)

Returns a MetadataType describing the given Field's type

Parameters:

field - a not null Field

typeLoader - a ClassTypeLoader used to create the MetadataType

Returns:

a MetadataType matching the field's type

Throws:

IllegalArgumentException - if field is null

getFieldByNameOrAlias

public static Optional<Field> getFieldByNameOrAlias(Class<?> clazz,
                                                    String nameOrAlias)

getField

public static Optional<Field> getField(Class<?> clazz,
                                       org.mule.runtime.api.meta.model.parameter.ParameterModel parameterModel)

getField

public static Optional<Field> getField(Class<?> clazz,
                                       org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclaration parameterDeclaration)

getField

public static Optional<Field> getField(Class<?> clazz,
                                       String name)

getFieldValue

public static Object getFieldValue(Object object,
                                   String fieldName)
                            throws IllegalAccessException,
                                   NoSuchFieldException

Resolves and returns the field value of an object instance

Parameters:

object - The object where grab the field value

fieldName - The name of the field to obtain the value

Returns:

The value of the field with the given fieldName and object instance

Throws:

IllegalAccessException - if is unavailable to access to the field

NoSuchFieldException - if the field doesn't exist in the given object instance

getMemberName

public static String getMemberName(org.mule.runtime.api.meta.model.EnrichableModel enrichableModel,
                                   String defaultName)

hasDefaultConstructor

public static boolean hasDefaultConstructor(Class<?> clazz)

getInterfaceGenerics

public static List<Class<?>> getInterfaceGenerics(Class<?> type,
                                                  Class<?> implementedInterface)

findGenericsInSuperHierarchy

public static List<Class<?>> findGenericsInSuperHierarchy(Class<?> type)

getSuperClassGenerics

public static List<Type> getSuperClassGenerics(Class<?> type,
                                               Class<?> superClass)

checkInstantiable

public static void checkInstantiable(Class<?> declaringClass)

checkInstantiable

public static void checkInstantiable(Class<?> declaringClass,
                                     boolean requireDefaultConstructor)

isInstantiable

public static boolean isInstantiable(org.mule.metadata.api.model.MetadataType type)

isInstantiable

public static boolean isInstantiable(Class<?> declaringClass)

isInstantiable

public static boolean isInstantiable(Class<?> declaringClass,
                                     boolean requireDefaultConstructor)

assignableFromAny

public static boolean assignableFromAny(Class<?> type,
                                        Collection<Class<?>> matchingTypes)

Determines if the given type is assignable from any of the matchingTypes

Parameters:

type - a Class

matchingTypes - a collection of classes to test against

Returns:

whether the type is assignable or not

isRequired

public static boolean isRequired(AccessibleObject object)

isRequired

public static boolean isRequired(org.mule.runtime.api.meta.model.parameter.ParameterModel parameterModel,
                                 boolean forceOptional)

isVoid

public static boolean isVoid(Method method)

isVoid

public static boolean isVoid(org.mule.runtime.api.meta.model.ComponentModel componentModel)

getApiMethods

public static Collection<Method> getApiMethods(Class<?> declaringClass)

getMethodsAnnotatedWith

public static Collection<Method> getMethodsAnnotatedWith(Class<?> declaringClass,
                                                         Class<? extends Annotation> annotationType)

Returns all the methods in the declaringClass which are annotated with annotationType, including those declared in super classes.

Parameters:

declaringClass - the type to introspect

annotationType - the annotation you're looking for

Returns:

a Collection of Methods

getMethodsAnnotatedWith

public static Collection<Method> getMethodsAnnotatedWith(Class<?> declaringClass,
                                                         Class<? extends Annotation> annotationType,
                                                         boolean superClasses)

Returns all the methods in the declaringClass which are annotated with annotationType

Parameters:

declaringClass - the type to introspect

annotationType - the annotation you're looking for

superClasses - whether to consider supper classes or not

Returns:

a Collection of Methods

getAnnotatedFields

public static List<Field> getAnnotatedFields(Class<?> clazz,
                                             Class<? extends Annotation> annotationType)

getFields

public static List<Field> getFields(Class<?> clazz)

getFieldsOfType

public static List<Field> getFieldsOfType(Class<?> introspectedType,
                                          Class fieldType)

getAlias

public static <T extends AnnotatedElement & Member> String getAlias(T element)

Returns the Alias name of the given element. If the element doesn't have an alias, then the default name is return

Type Parameters:

T - the generic type of the element

Parameters:

element - an annotated member

Returns:

an alias name

getExposedFields

public static Collection<Field> getExposedFields(Class<?> extensionType)

getFieldsWithGetters

public static Set<Field> getFieldsWithGetters(Class<?> extensionType)

getExpressionSupport

public static org.mule.runtime.api.meta.ExpressionSupport getExpressionSupport(AnnotatedElement object)

getExpressionSupport

public static org.mule.runtime.api.meta.ExpressionSupport getExpressionSupport(org.mule.runtime.extension.api.annotation.Expression expressionAnnotation)

getSourceName

public static String getSourceName(Class<? extends org.mule.runtime.extension.api.runtime.source.Source> sourceType)

getAnnotation

public static <T extends Annotation> T getAnnotation(Class<?> annotatedClass,
                                                     Class<T> annotationClass)

Looks for the annotation in the given class. If the annotation is not found, it keeps looking recursively for it in the superClass until it finds it or there is no superClass to analyze.

getParameterClasses

public static Set<Class<?>> getParameterClasses(org.mule.runtime.api.meta.model.ExtensionModel extensionModel,
                                                ClassLoader extensionClassLoader)

Traverses through all the ParameterModels of the extensionModel and returns the classes that are modeled by each parameter's Typed.getType().

This includes every single ParameterModel in the model, including configs, providers, operations, etc.

Parameters:

extensionModel - a ExtensionModel

Returns:

a non null Set

collectRelativeClasses

public static Set<Class<?>> collectRelativeClasses(org.mule.metadata.api.model.MetadataType type,
                                                   ClassLoader extensionClassLoader)

Given a MetadataType it adds all the Class that are related from that type. This includes generics of an ArrayType, open restriction of an ObjectType as well as its fields.

Parameters:

type - MetadataType to inspect

extensionClassLoader - extension class loader

Returns:

Set> with the classes reachable from the type

isMultiLevelMetadataKeyId

public static boolean isMultiLevelMetadataKeyId(Set<Class<? extends Annotation>> annotations,
                                                org.mule.metadata.api.model.MetadataType parameterType)

Given a Set of Annotation classes and a MetadataType that describes a component parameter, indicates if the parameter is considered as a multilevel MetadataKeyId

Parameters:

annotations - of the parameter

parameterType - of the parameter

Returns:

a boolean indicating if the Parameter is considered as a multilevel MetadataKeyId

isParameterContainer

public static boolean isParameterContainer(Set<Class<? extends Annotation>> annotations,
                                           org.mule.metadata.api.model.MetadataType parameterType)

Given a Set of annotation classes and a MetadataType of a component parameter, indicates if the parameter is a parameter container.

To be a parameter container means that the parameter is a ParameterGroup or a multilevel MetadataKeyId.

Parameters:

annotations - of the component parameter

parameterType - of the component parameter

Returns:

a boolean indicating if the parameter is considered as a parameter container

getAnnotatedElement

public static Optional<AnnotatedElement> getAnnotatedElement(org.mule.runtime.api.meta.model.declaration.fluent.BaseDeclaration<?> declaration)

getContainerName

public static String getContainerName(AnnotatedElement container)

getGroupModelContainerName

public static String getGroupModelContainerName(org.mule.runtime.api.meta.model.parameter.ParameterGroupModel groupModel)

getImplementingName

public static String getImplementingName(org.mule.runtime.api.meta.model.declaration.fluent.ParameterDeclaration parameterDeclaration)

Resolves the original name of a parameter before it was modified due to the usage of an Alias.

Parameters:

parameterDeclaration - parameter from which look for their original name

Returns:

the original name

getImplementingName

public static String getImplementingName(org.mule.runtime.api.meta.model.parameter.ParameterModel parameterModel)

Resolves the original name of a parameter before it was modified due to the usage of an Alias.

Parameters:

parameterModel - parameter from which look for their original name

Returns:

the original name

isParameterResolver

public static boolean isParameterResolver(org.mule.metadata.api.model.MetadataType metadataType)

isTargetParameter

public static boolean isTargetParameter(Set<org.mule.runtime.api.meta.model.ModelProperty> modelProperties)

isLiteral

public static boolean isLiteral(org.mule.metadata.api.model.MetadataType metadataType)

isTypedValue

public static boolean isTypedValue(org.mule.metadata.api.model.MetadataType metadataType)

getConnectionProviderModel

public static Optional<org.mule.runtime.api.meta.model.connection.ConnectionProviderModel> getConnectionProviderModel(Class<? extends org.mule.runtime.api.connection.ConnectionProvider> connectionProvider,
                                                                                                                      List<org.mule.runtime.api.meta.model.connection.ConnectionProviderModel> allConnectionProviders)

Resolves the correspondent ConnectionProviderModel for a given ConnectionProvider instance.

Parameters:

connectionProvider - connection provider class

allConnectionProviders - list of available ConnectionProviderModel

Returns:

an Optional value of the ConnectionProviderModel

injectFields

public static void injectFields(org.mule.runtime.api.meta.model.EnrichableModel model,
                                Object target,
                                String configName,
                                String encoding)

Sets the configName into the field of the target annotated RefName (if it's present) and does the same for the encoding and the field annotated with DefaultEncoding if the model contains the DeclaringMemberModelProperty

Parameters:

model - enriched with InjectedFieldModelProperty

target - object in which the fields are going to be set

configName - to be injected into the String field annotated with RefName

encoding - to be injected into the String field annotated with DefaultEncoding

injectDefaultEncoding

public static void injectDefaultEncoding(org.mule.runtime.api.meta.model.EnrichableModel model,
                                         Object target,
                                         String encoding)

Sets the encoding value into the field of the target annotated DefaultEncoding if the model contains the DeclaringMemberModelProperty property and the value is not null.

Parameters:

model - enriched with DefaultEncodingModelProperty

target - object in which the fields are going to be set

encoding - to be injected into the String field annotated with DefaultEncoding

injectFields

public static void injectFields(Object target,
                                String configName,
                                String encoding)

Sets the configName into the field of the target annotated RefName (if it's present) and does the same for the encoding and the field annotated with DefaultEncoding.

Parameters:

target - object in which the fields are going to be set

configName - to be injected into the String field annotated with RefName

encoding - to be injected into the String field annotated with DefaultEncoding

Throws:

{@link - IllegalModelDefinitionException} if there is more than one field annotated with DefaultEncoding

injectRefName

public static void injectRefName(Object target,
                                 String configName)

Introspects the target object for a field annotated with RefName. If found, it injects the configName value into it.

The target object is expected to have only one field annotated with RefName and that field is required to be a String.

Parameters:

target - object in which the value are going to be set

configName - the value to be injected

injectDefaultEncoding

public static void injectDefaultEncoding(Object target,
                                         String encoding)

Sets the encoding value into the field of the target annotated DefaultEncoding (if present)

Parameters:

target - object in which the fields are going to be set

encoding - to be injected into the String field annotated with DefaultEncoding

Throws:

{@link - IllegalModelDefinitionException} if there is more than one field annotated with DefaultEncoding

getDefaultEncodingFieldSetter

public static Optional<FieldSetter> getDefaultEncodingFieldSetter(Object target)

Returns a FieldSetter for a field in the target annotated DefaultEncoding (if present)

Parameters:

target - object in which the fields are going to be set

Throws:

{@link - IllegalModelDefinitionException} if there is more than one field annotated with DefaultEncoding

injectComponentLocation

public static void injectComponentLocation(Object target,
                                           org.mule.runtime.api.component.location.ComponentLocation componentLocation)

Introspects the target object for a field of type ComponentLocation. If found, it injects the componentLocation value into it.

The target object is expected to have only one field of such type.

Parameters:

target - object in which the value are going to be set

componentLocation - the value to be injected

getPagingProviderTypes

public static org.mule.runtime.api.util.Pair<org.springframework.core.ResolvableType,org.springframework.core.ResolvableType> getPagingProviderTypes(org.springframework.core.ResolvableType pagingProvider)

Introspects a PagingProvider type and returns their generics.

Parameters:

pagingProvider - PagingProvider to introspect

Returns:

The PagingProvider generics.