@Override public Type getValidatedValueType(final Type type) { final ResolvedType resolvedType = resolver.resolve(type); return resolvedType.typeParametersFor(Optional.class).get(0).getErasedType(); } }
@Override public Type getValidatedValueType(final Type type) { return resolver.resolve(type) .typeParametersFor(AbstractParam.class).get(0) .getErasedType(); } }
@SuppressWarnings("WeakerAccess") public AbstractConverterDescriptor( Class<? extends AttributeConverter> converterClass, Boolean forceAutoApply, ClassmateContext classmateContext) { this.converterClass = converterClass; final ResolvedType converterType = classmateContext.getTypeResolver().resolve( converterClass ); final List<ResolvedType> converterParamTypes = converterType.typeParametersFor( AttributeConverter.class ); if ( converterParamTypes == null ) { throw new AnnotationException( "Could not extract type parameter information from AttributeConverter implementation [" + converterClass.getName() + "]" ); } else if ( converterParamTypes.size() != 2 ) { throw new AnnotationException( "Unexpected type parameter information for AttributeConverter implementation [" + converterClass.getName() + "]; expected 2 parameter types, but found " + converterParamTypes.size() ); } this.domainType = converterParamTypes.get( 0 ); this.jdbcType = converterParamTypes.get( 1 ); this.autoApplicableDescriptor = resolveAutoApplicableDescriptor( converterClass, forceAutoApply ); }
@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; }
public ResultBearingResultReturnThing(ResolvedMethod method) { // extract T from Query<T> ResolvedType query_type = method.getReturnType(); List<ResolvedType> query_return_types = query_type.typeParametersFor(org.skife.jdbi.v2.Query.class); this.resolvedType = query_return_types.get(0); }
public IteratorResultReturnThing(ResolvedMethod method) { ResolvedType query_type = method.getReturnType(); List<ResolvedType> query_return_types = query_type.typeParametersFor(Iterator.class); this.resolvedType = query_return_types.get(0); }
public static <T extends Collection> ResolvedType elementType(ResolvedType container, Class<T> collectionType) { List<ResolvedType> resolvedTypes = container.typeParametersFor(collectionType); if (resolvedTypes.size() == 1) { return resolvedTypes.get(0); } return new TypeResolver().resolve(Object.class); }
public static <T extends Collection> ResolvedType elementType(ResolvedType container, Class<T> collectionType) { List<ResolvedType> resolvedTypes = container.typeParametersFor(collectionType); if (resolvedTypes.size() == 1) { return resolvedTypes.get(0); } return new TypeResolver().resolve(Object.class); }
public InferredMapperFactory(ResultSetMapper mapper) { this.mapper = mapper; ResolvedType rt = tr.resolve(mapper.getClass()); List<ResolvedType> rs = rt.typeParametersFor(ResultSetMapper.class); if (rs.isEmpty() || rs.get(0).getErasedType().equals(Object.class)) { throw new UnsupportedOperationException("Must use a concretely typed ResultSetMapper here"); } maps = rs.get(0).getErasedType(); }
private static <T extends Collection> ResolvedType elementType(ResolvedType container, Class<T> collectionType) { List<ResolvedType> resolvedTypes = container.typeParametersFor(collectionType); if (resolvedTypes.size() == 1) { return resolvedTypes.get(0); } return new TypeResolver().resolve(Object.class); } }
@Override public Type getValidatedValueType(final Type type) { final ResolvedType resolvedType = resolver.resolve(type); return resolvedType.typeParametersFor(Optional.class).get(0).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(); } }
private Object resolvParam(NamedDefaultedRestParam param, List<String> values, ResolvedType resolvedType) { if (param.getType().isInstanceOf(List.class) && values.size() != 1) { ResolvedType itemType = param.getType().typeParametersFor(List.class).get(0); return values.stream().map(value -> RestParam.convert(value, itemType)).collect(Collectors.toList()); } else { return RestParam.convert(Iterables.getFirst(values, null), resolvedType); } }
public class OptionalValidatedValueUnwrapper extends ValidatedValueUnwrapper<Optional<?>> { private final TypeResolver resolver = new TypeResolver(); @Override public Object handleValidatedValue(final Optional<?> optional) { return optional.orNull(); } @Override public Type getValidatedValueType(final Type type) { ResolvedType resolvedType = resolver.resolve(type); return resolvedType.typeParametersFor(Optional.class).get(0).getErasedType(); } }
public IterableReturningThing(ResolvedMethod method) { // extract T from List<T> ResolvedType query_type = method.getReturnType(); List<ResolvedType> query_return_types = query_type.typeParametersFor(Iterable.class); this.resolvedType = query_return_types.get(0); erased_type = method.getReturnType().getErasedType(); }
@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(); }