public static boolean isInstance(Type type, Object object) { return getErasedReferenceType( type ).isInstance( object ); }
public static boolean isInstance(Type type, Object object) { return getErasedReferenceType( type ).isInstance( object ); }
private static Map<Type, Type> getActualTypeArgumentsByParameterInternal(Type type) { // TODO: look deeply within non-parameterized types when visitors implemented if ( !( type instanceof ParameterizedType ) ) { return Collections.emptyMap(); } TypeVariable<?>[] typeParameters = getErasedReferenceType( type ).getTypeParameters(); Type[] typeArguments = ( (ParameterizedType) type ).getActualTypeArguments(); if ( typeParameters.length != typeArguments.length ) { throw new MalformedParameterizedTypeException(); } Map<Type, Type> actualTypeArgumentsByParameter = new LinkedHashMap<>(); for ( int i = 0; i < typeParameters.length; i++ ) { // we only add the mapping if it is not a cyclic dependency (see HV-1032) if ( !typeParameters[i].equals( typeArguments[i] ) ) { actualTypeArgumentsByParameter.put( typeParameters[i], typeArguments[i] ); } } return actualTypeArgumentsByParameter; }
private static Map<Type, Type> getActualTypeArgumentsByParameterInternal(Type type) { // TODO: look deeply within non-parameterized types when visitors implemented if ( !( type instanceof ParameterizedType ) ) { return Collections.emptyMap(); } TypeVariable<?>[] typeParameters = getErasedReferenceType( type ).getTypeParameters(); Type[] typeArguments = ( (ParameterizedType) type ).getActualTypeArguments(); if ( typeParameters.length != typeArguments.length ) { throw new MalformedParameterizedTypeException(); } Map<Type, Type> actualTypeArgumentsByParameter = new LinkedHashMap<Type, Type>(); for ( int i = 0; i < typeParameters.length; i++ ) { // we only add the mapping if it is not a cyclic dependency (see HV-1032) if ( !typeParameters[i].equals( typeArguments[i] ) ) { actualTypeArgumentsByParameter.put( typeParameters[i], typeArguments[i] ); } } return actualTypeArgumentsByParameter; }
private static Type getResolvedSuperclass(Type type) { Contracts.assertNotNull( type, "type" ); Class<?> rawType = getErasedReferenceType( type ); Type supertype = rawType.getGenericSuperclass(); if ( supertype == null ) { return null; } return resolveTypeVariables( supertype, type ); }
private static Type[] getResolvedInterfaces(Type type) { Contracts.assertNotNull( type, "type" ); Class<?> rawType = getErasedReferenceType( type ); Type[] interfaces = rawType.getGenericInterfaces(); Type[] resolvedInterfaces = new Type[interfaces.length]; for ( int i = 0; i < interfaces.length; i++ ) { resolvedInterfaces[i] = resolveTypeVariables( interfaces[i], type ); } return resolvedInterfaces; }
private static Type getResolvedSuperclass(Type type) { Contracts.assertNotNull( type, "type" ); Class<?> rawType = getErasedReferenceType( type ); Type supertype = rawType.getGenericSuperclass(); if ( supertype == null ) { return null; } return resolveTypeVariables( supertype, type ); }
private static <T> ParameterizedType parameterizeClassCapture(Class<T> type, Map<Type, Type> actualTypeArgumentsByParameter) { // TODO: actualTypeArgumentsByParameter should be Map<TypeVariable<Class<T>>, Type> TypeVariable<Class<T>>[] typeParameters = type.getTypeParameters(); Type[] actualTypeArguments = new Type[typeParameters.length]; for ( int i = 0; i < typeParameters.length; i++ ) { TypeVariable<Class<T>> typeParameter = typeParameters[i]; Type actualTypeArgument = actualTypeArgumentsByParameter.get( typeParameter ); if ( actualTypeArgument == null ) { throw LOG.getMissingActualTypeArgumentForTypeParameterException( typeParameter ); } actualTypeArguments[i] = actualTypeArgument; } return parameterizedType( getErasedReferenceType( type ), actualTypeArguments ); }
private static Type[] getResolvedInterfaces(Type type) { Contracts.assertNotNull( type, "type" ); Class<?> rawType = getErasedReferenceType( type ); Type[] interfaces = rawType.getGenericInterfaces(); Type[] resolvedInterfaces = new Type[interfaces.length]; for ( int i = 0; i < interfaces.length; i++ ) { resolvedInterfaces[i] = resolveTypeVariables( interfaces[i], type ); } return resolvedInterfaces; }
private static <T> ParameterizedType parameterizeClassCapture(Class<T> type, Map<Type, Type> actualTypeArgumentsByParameter) { // TODO: actualTypeArgumentsByParameter should be Map<TypeVariable<Class<T>>, Type> TypeVariable<Class<T>>[] typeParameters = type.getTypeParameters(); Type[] actualTypeArguments = new Type[typeParameters.length]; for ( int i = 0; i < typeParameters.length; i++ ) { TypeVariable<Class<T>> typeParameter = typeParameters[i]; Type actualTypeArgument = actualTypeArgumentsByParameter.get( typeParameter ); if ( actualTypeArgument == null ) { throw log.getMissingActualTypeArgumentForTypeParameterException( typeParameter ); } actualTypeArguments[i] = actualTypeArgument; } return parameterizedType( getErasedReferenceType( type ), actualTypeArguments ); }
private static Type resolveTypeVariables(Type type, Type subtype) { // TODO: need to support other types in future, e.g. T[], etc. if ( !( type instanceof ParameterizedType ) ) { return type; } Map<Type, Type> actualTypeArgumentsByParameter = getActualTypeArgumentsByParameter( type, subtype ); Class<?> rawType = getErasedReferenceType( type ); return parameterizeClass( rawType, actualTypeArgumentsByParameter ); }
/** * Used to determine the value extractor candidates valid for a declared type and type variable. * <p> * The effective value extractor will be narrowed from these candidates using the runtime type. * <p> * Used to optimize the choice of the value extractor in the case of cascading validation. */ public Set<ValueExtractorDescriptor> getValueExtractorCandidatesForCascadedValidation(Type declaredType, TypeVariable<?> typeParameter) { Set<ValueExtractorDescriptor> valueExtractorDescriptors = new HashSet<>(); valueExtractorDescriptors.addAll( getRuntimeAndContainerElementCompliantValueExtractorsFromPossibleCandidates( declaredType, typeParameter, TypeHelper.getErasedReferenceType( declaredType ), registeredValueExtractors ) ); valueExtractorDescriptors.addAll( getPotentiallyRuntimeTypeCompliantAndContainerElementCompliantValueExtractors( declaredType, typeParameter ) ); return CollectionHelper.toImmutableSet( valueExtractorDescriptors ); }
@SuppressWarnings("rawtypes") private static Class<?> getContainerType(AnnotatedParameterizedType valueExtractorDefinition, Class<? extends ValueExtractor> extractorImplementationType) { AnnotatedType containerType = valueExtractorDefinition.getAnnotatedActualTypeArguments()[0]; return TypeHelper.getErasedReferenceType( containerType.getType() ); }
private static Type resolveTypeVariables(Type type, Type subtype) { // TODO: need to support other types in future, e.g. T[], etc. if ( !( type instanceof ParameterizedType ) ) { return type; } Map<Type, Type> actualTypeArgumentsByParameter = getActualTypeArgumentsByParameter( type, subtype ); Class<?> rawType = getErasedReferenceType( type ); return parameterizeClass( rawType, actualTypeArgumentsByParameter ); }
TypeArgumentConstraintLocation(ConstraintLocation delegate, TypeVariable<?> typeParameter, Type typeOfAnnotatedElement) { this.delegate = delegate; this.typeParameter = typeParameter; this.typeForValidatorResolution = ReflectionHelper.boxedType( typeOfAnnotatedElement ); this.containerClass = TypeHelper.getErasedReferenceType( delegate.getTypeForValidatorResolution() ); ConstraintLocation outerDelegate = delegate; while ( outerDelegate instanceof TypeArgumentConstraintLocation ) { outerDelegate = ( (TypeArgumentConstraintLocation) outerDelegate ).delegate; } this.outerDelegate = outerDelegate; this.hashCode = buildHashCode( delegate, typeParameter ); }
private Set<ValueExtractorDescriptor> getRuntimeAndContainerElementCompliantValueExtractorsFromPossibleCandidates(Type declaredType, TypeVariable<?> typeParameter, Class<?> runtimeType, Collection<ValueExtractorDescriptor> valueExtractorCandidates) { if ( nonContainerTypes.contains( runtimeType ) ) { return Collections.emptySet(); } ValueExtractorCacheKey cacheKey = new ValueExtractorCacheKey( runtimeType, typeParameter ); Set<ValueExtractorDescriptor> valueExtractorDescriptors = possibleValueExtractorsByRuntimeTypeAndTypeParameter.get( cacheKey ); if ( valueExtractorDescriptors != null ) { return valueExtractorDescriptors; } boolean isInternal = TypeVariables.isInternal( typeParameter ); Class<?> erasedDeclaredType = TypeHelper.getErasedReferenceType( declaredType ); Set<ValueExtractorDescriptor> possibleValueExtractors = valueExtractorCandidates .stream() .filter( e -> TypeHelper.isAssignable( e.getContainerType(), runtimeType ) ) .filter( extractorDescriptor -> checkValueExtractorTypeCompatibility( typeParameter, isInternal, erasedDeclaredType, extractorDescriptor ) ).collect( Collectors.toSet() ); valueExtractorDescriptors = getMaximallySpecificValueExtractors( possibleValueExtractors ); if ( valueExtractorDescriptors.isEmpty() ) { nonContainerTypes.add( runtimeType ); return Collections.emptySet(); } Set<ValueExtractorDescriptor> valueExtractorDescriptorsToCache = CollectionHelper.toImmutableSet( valueExtractorDescriptors ); Set<ValueExtractorDescriptor> cachedValueExtractorDescriptors = possibleValueExtractorsByRuntimeTypeAndTypeParameter.putIfAbsent( cacheKey, valueExtractorDescriptorsToCache ); return cachedValueExtractorDescriptors != null ? cachedValueExtractorDescriptors : valueExtractorDescriptorsToCache; }
TypeVariable<?> typeParameter) { boolean isInternal = TypeVariables.isInternal( typeParameter ); Type erasedDeclaredType = TypeHelper.getErasedReferenceType( declaredType );
Class<?> declaredType = TypeHelper.getErasedReferenceType( location.getTypeForValidatorResolution() ); Set<ValueExtractorDescriptor> valueExtractorDescriptorCandidates = valueExtractorManager.getResolver().getMaximallySpecificValueExtractors( declaredType ); ValueExtractorDescriptor selectedValueExtractorDescriptor;