@Override public Type getValidatedValueType(final Type type) { return resolver.resolve(type) .typeParametersFor(AbstractParam.class).get(0) .getErasedType(); } }
@Override public Type getValidatedValueType(final Type type) { final ResolvedType resolvedType = resolver.resolve(type); return resolvedType.typeParametersFor(Optional.class).get(0).getErasedType(); } }
boolean isMethodCorrect(ResolvedMethod m) { if (m.getReturnType()!=null) { log.error("The method {} is annotated with @SelfValidation but does not return void. It is ignored", m.getRawMember()); return false; } else if (m.getArgumentCount() != 1 || !m.getArgumentType(0).getErasedType().equals(ViolationCollector.class)) { log.error("The method {} is annotated with @SelfValidation but does not have a single parameter of type {}", m.getRawMember(), ViolationCollector.class); return false; } else if (!m.isPublic()) { log.error("The method {} is annotated with @SelfValidation but is not public", m.getRawMember()); return false; } return true; }
private boolean typesMatch(ResolvedType converterDefinedType, ResolvedType checkType) { if ( !converterDefinedType.getErasedType().isAssignableFrom( checkType.getErasedType() ) ) { return false;
@Override public ConverterDescriptor getAutoAppliedConverterDescriptorForCollectionElement( XProperty xProperty, MetadataBuildingContext context) { final ResolvedMember collectionMember = resolveMember( xProperty, context ); final ResolvedType elementType; if ( Map.class.isAssignableFrom( collectionMember.getType().getErasedType() ) ) { elementType = collectionMember.getType().typeParametersFor( Map.class ).get( 1 ); } else if ( Collection.class.isAssignableFrom( collectionMember.getType().getErasedType() ) ) { elementType = collectionMember.getType().typeParametersFor( Collection.class ).get( 0 ); } else { throw new HibernateException( "Attribute was neither a Collection nor a Map : " + collectionMember.getType().getErasedType() ); } return typesMatch( linkedConverterDescriptor.getDomainValueResolvedType(), elementType ) ? linkedConverterDescriptor : null; }
@Override public ConverterDescriptor getAutoAppliedConverterDescriptorForMapKey( XProperty xProperty, MetadataBuildingContext context) { final ResolvedMember collectionMember = resolveMember( xProperty, context ); final ResolvedType keyType; if ( Map.class.isAssignableFrom( collectionMember.getType().getErasedType() ) ) { keyType = collectionMember.getType().typeParametersFor( Map.class ).get( 0 ); } else { throw new HibernateException( "Attribute was not a Map : " + collectionMember.getType().getErasedType() ); } return typesMatch( linkedConverterDescriptor.getDomainValueResolvedType(), keyType ) ? linkedConverterDescriptor : null; }
@Override @SuppressWarnings("unchecked") public JpaAttributeConverter createJpaAttributeConverter(JpaAttributeConverterCreationContext context) { return new JpaAttributeConverterImpl( createManagedBean( context ), context.getJavaTypeDescriptorRegistry().getDescriptor( getAttributeConverterClass() ), context.getJavaTypeDescriptorRegistry().getDescriptor( getDomainValueResolvedType().getErasedType() ), context.getJavaTypeDescriptorRegistry().getDescriptor( getRelationalValueResolvedType().getErasedType() ) ); }
.resolve(method.getInvocable().getResponseType()); final Class<?> erasedType = !responseType.getTypeBindings().isEmpty() ? responseType.getTypeBindings().getBoundType(0).getErasedType() : responseType.getErasedType();
private boolean isGenericTypeSubclass(ResolvedType candidateMethodReturnValue, Type returnValueOnMethod) { return returnValueOnMethod instanceof ParameterizedType && candidateMethodReturnValue.getErasedType() .isAssignableFrom((Class<?>) ((ParameterizedType) returnValueOnMethod).getRawType()); }
@VisibleForTesting boolean isSubClass(ResolvedType candidateMethodReturnValue, Type returnValueOnMethod) { return returnValueOnMethod instanceof Class && candidateMethodReturnValue.getErasedType().isAssignableFrom((Class<?>) returnValueOnMethod); }
public static boolean isContainerType(ResolvedType type) { if (List.class.isAssignableFrom(type.getErasedType()) || Set.class.isAssignableFrom(type.getErasedType()) || type.isArray()) { return true; } return false; }
public static String containerType(ResolvedType type) { if (List.class.isAssignableFrom(type.getErasedType())) { return "List"; } else if (Set.class.isAssignableFrom(type.getErasedType())) { return "Set"; } else if (type.isArray()) { return "Array"; } else { throw new UnsupportedOperationException(String.format("Type is not collection type %s", type)); } }
private boolean treatAsAString(ResolvedType parameterType) { return !(isBaseType(typeNameFor(parameterType.getErasedType())) || enumTypeDeterminer.isEnum(parameterType.getErasedType())); } }
/** * Resolves the single type parameter of the given target class, using the given sub-type. */ private static Class<?> resolveSingleTypeParameter(TypeResolver typeResolver, Type subType, Class<?> target) { ResolvedType resolvedType = typeResolver.resolve( subType ); return resolvedType.typeParametersFor( target ).get( 0 ).getErasedType(); } }
@Override public Type getValidatedValueType(final Type type) { return resolver.resolve(type) .typeParametersFor(AbstractParam.class).get(0) .getErasedType(); } }
/** * Method only used by test code: do not use otherwise. */ protected void _addForTest(ResolvedType type) { List<ResolvedType> tp = type.getTypeParameters(); ResolvedType[] tpa = tp.toArray(new ResolvedType[tp.size()]); put(key(type.getErasedType(), tpa), type); } }
/** * Method only used by test code: do not use otherwise. */ protected void _addForTest(ResolvedType type) { List<ResolvedType> tp = type.getTypeParameters(); ResolvedType[] tpa = tp.toArray(new ResolvedType[tp.size()]); put(key(type.getErasedType(), tpa), type); } }
@SuppressWarnings("rawtypes") private Class<?> determineAnnotationType(Class<? extends ConstraintValidator> constraintValidatorClass) { ResolvedType resolvedType = typeResolutionHelper.getTypeResolver() .resolve( constraintValidatorClass ); return resolvedType.typeParametersFor( ConstraintValidator.class ).get( 0 ).getErasedType(); }
private Class<?> determineAnnotationType(Class<?> constraintValidatorClass) { ResolvedType resolvedType = typeResolutionHelper.getTypeResolver() .resolve( constraintValidatorClass ); return resolvedType.typeParametersFor( ConstraintValidator.class ).get( 0 ).getErasedType(); }
/** * Returns the sub-types binding for the single type parameter of the super-type. E.g. for {@code IntegerProperty} * and {@code Property<T>}, {@code Integer} would be returned. */ private static Class<?> getWrappedValueType(TypeResolutionHelper typeResolutionHelper, Type declaredType, ValueExtractorDescriptor valueExtractorDescriptor) { ResolvedType resolvedType = typeResolutionHelper.getTypeResolver().resolve( declaredType ); List<ResolvedType> resolvedTypeParameters = resolvedType.typeParametersFor( valueExtractorDescriptor.getContainerType() ); if ( resolvedTypeParameters == null || resolvedTypeParameters.isEmpty() ) { throw LOG.getNoValueExtractorFoundForUnwrapException( declaredType ); } return resolvedTypeParameters.get( TypeVariables.getTypeParameterIndex( valueExtractorDescriptor.getExtractedTypeParameter() ) ).getErasedType(); }