Refine search
@Override public Type getValidatedValueType(final Type type) { return resolver.resolve(type) .typeParametersFor(AbstractParam.class).get(0) .getErasedType(); } }
case SUB_RESOURCE_LOCATOR: final ResolvedType responseType = TYPE_RESOLVER .resolve(method.getInvocable().getResponseType()); final Class<?> erasedType = !responseType.getTypeBindings().isEmpty() ? responseType.getTypeBindings().getBoundType(0).getErasedType() : responseType.getErasedType();
private boolean typesMatch(ResolvedType converterDefinedType, ResolvedType checkType) { if ( !converterDefinedType.getErasedType().isAssignableFrom( checkType.getErasedType() ) ) { return false; if ( converterDefinedType.getTypeParameters().isEmpty() ) { return true; if ( checkType.getTypeParameters().isEmpty() ) { if ( converterDefinedType.getTypeParameters().size() != checkType.getTypeParameters().size() ) { for ( int i = 0; i < converterDefinedType.getTypeParameters().size(); i++ ) { if ( !typesMatch( converterDefinedType.getTypeParameters().get( i ), checkType.getTypeParameters().get( i ) ) ) { 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; }
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(); } }
@Override protected ResolvedType realType() { if (isGetter) { if (method.getReturnType().getErasedType().getTypeParameters().length > 0) { return method.getReturnType(); } else { return typeResolver.resolve(method.getReturnType().getErasedType()); } } else { if (method.getArgumentType(0).getErasedType().getTypeParameters().length > 0) { return method.getArgumentType(0); } else { return typeResolver.resolve(method.getArgumentType(0).getErasedType()); } } }
private static ResolvedType breadthFirstReplace(Iterator<ResolvedType> replaceableIterator, ResolvedType wildcardType) { if (WildcardType.class.equals(wildcardType.getErasedType())) { if (replaceableIterator.hasNext()) { return replaceableIterator.next(); } else { throw new IllegalStateException("Expecting the same number of wildcard types as the replaceables"); } } TypeBindings wildcardTypeBindings = wildcardType.getTypeBindings(); List<Type> bindings = newArrayList(); for (int index = 0; index < wildcardTypeBindings.size(); index++) { if (WildcardType.class.equals(wildcardTypeBindings.getBoundType(index).getErasedType())) { if (replaceableIterator.hasNext()) { bindings.add(replaceableIterator.next()); } else { throw new IllegalStateException("Count of wildcards to candidates do not match"); } } else { bindings.add(breadthFirstReplace(replaceableIterator, wildcardTypeBindings.getBoundType(index))); } } return new TypeResolver().resolve(wildcardType.getErasedType(), toArray(bindings, Type.class)); }
ResolvedType resolvedSubType = typeResolver.resolve(subTypeMethod.getDeclaringClass()); MemberResolver memberResolver = new MemberResolver(typeResolver); memberResolver.setMethodFilter(new SimpleMethodFilter(subTypeMethod, superTypeMethod)); for (int i = 0; i < resolvedMethods[0].getArgumentCount(); i++) if (!resolvedMethods[0].getArgumentType(i).equals(resolvedMethods[1].getArgumentType(i)))
/** * This method constructs a Java object from Bali code. * * @param <T> the concreteClass type that will be returned * @param componentNode The root Bali parse tree node. * @param genericType The generic type of the object * @return The Java object. */ public <T> T toObject(ComponentNode componentNode, GenericType<T> genericType) { ResolvedType resolvedType = typeResolver.resolve(genericType); List<ResolvedType> resolvedTypeParameters = resolvedType.getTypeParameters(); Class<?>[] parameterTypes = new Class<?>[resolvedTypeParameters.size()]; for (int i = 0; i < parameterTypes.length; i++) { parameterTypes[i] = resolvedTypeParameters.get(i).getErasedType(); } return toObject(componentNode, resolvedType.getErasedType(), parameterTypes); }
/** * Factory method for constructing array type of given element type. */ public ResolvedArrayType arrayType(Type elementType) { ResolvedType resolvedElementType = resolve(TypeBindings.emptyBindings(), elementType); // Arrays are cumbersome for some reason: Object emptyArray = Array.newInstance(resolvedElementType.getErasedType(), 0); // Should we try to use cache? It's bit tricky, so let's not bother yet return new ResolvedArrayType(emptyArray.getClass(), TypeBindings.emptyBindings(), resolvedElementType); }
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; }
public boolean hasSeenBefore(ResolvedType resolvedType) { return seenTypes.contains(resolvedType) || seenTypes.contains(new TypeResolver().resolve(resolvedType.getErasedType())) || parentHasSeenBefore(resolvedType); }
@Override public boolean appliesTo(ResolvedType type) { return type.getErasedType() == genericType && !type.getTypeBindings().isEmpty() && boundTypeIndex <= type.getTypeBindings().size() - 1; }
final TypeBindings bindings = context.getTypeBindings(); Method m = raw.getRawMember(); Type rawType = m.getGenericReturnType(); ResolvedType rt = (rawType == Void.TYPE) ? null : _typeResolver.resolve(bindings, rawType); Type[] rawTypes = m.getGenericParameterTypes(); ResolvedType[] argTypes; argTypes = new ResolvedType[rawTypes.length]; for (int i = 0, len = rawTypes.length; i < len; ++i) { argTypes[i] = _typeResolver.resolve(bindings, rawTypes[i]); ResolvedMethod method = new ResolvedMethod(context, anns, m, rt, argTypes); for (int i = 0; i < argTypes.length; i++) { for (Annotation ann : annotations[i]) { method.applyParamOverride(i, ann);
/** * Method for resolving individual field completely */ protected ResolvedField resolveField(RawField raw) { final ResolvedType context = raw.getDeclaringType(); Field field = raw.getRawMember(); ResolvedType type = _typeResolver.resolve(context.getTypeBindings(), field.getGenericType()); // And then annotations Annotations anns = new Annotations(); for (Annotation ann : field.getAnnotations()) { if (_annotationHandler.includeFieldAnnotation(ann)) { anns.add(ann); } } return new ResolvedField(context, anns, field, type); }
@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 ); }
public boolean hasSeenBefore(ResolvedType resolvedType) { return seenTypes.contains(resolvedType) || seenTypes.contains(asResolved(new TypeResolver(), resolvedType.getErasedType())) // DK TODO : fix // alternate types || parentHasSeenBefore(resolvedType); }
ResolvedType resolvedType = methodParameter.getParameterType(); if (pageableType.equals(resolvedType)) { ParameterContext parameterContext = new ParameterContext(methodParameter, new ParameterBuilder(), Function<ResolvedType, ? extends ModelReference> factory = createModelRefFactory(parameterContext); ModelReference intModel = factory.apply(resolver.resolve(Integer.TYPE)); ModelReference stringModel = factory.apply(resolver.resolve(List.class, String.class));
public SingleValueResultReturnThing(ResolvedMethod method) { if (method.getRawMember().isAnnotationPresent(SingleValueResult.class)) { SingleValueResult svr = method.getRawMember().getAnnotation(SingleValueResult.class); // try to guess generic type if(SingleValueResult.Default.class == svr.value()){ TypeBindings typeBindings = method.getReturnType().getTypeBindings(); if(typeBindings.size() == 1){ this.returnType = typeBindings.getBoundType(0).getErasedType(); }else{ throw new IllegalArgumentException("Ambiguous generic information. SingleValueResult type could not be fetched."); } }else{ this.returnType = svr.value(); } this.containerType = method.getReturnType().getErasedType(); } else { this.returnType = method.getReturnType().getErasedType(); this.containerType = null; } }
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(); }