Refine search
@Override public Type getValidatedValueType(final Type type) { return resolver.resolve(type) .typeParametersFor(AbstractParam.class).get(0) .getErasedType(); } }
private Class<?> fieldType(AlternateTypeProvider alternateTypeProvider, Field field) { Class<?> type = field.getType(); ResolvedType resolvedType = resolver.resolve(type); ResolvedType alternativeType = alternateTypeProvider.alternateFor(resolvedType); Class<?> erasedType = alternativeType.getErasedType(); if (type != erasedType) { LOG.debug("Found alternative type [{}] for field: [{}-{}]", erasedType, field, type); } return erasedType; }
TypeResolver typeResolver = new TypeResolver(); // type token for Processor<Integer, String> ResolvedType type = typeResolver.resolve(Processor.class, Integer.class, String.class); System.out.println("type = " + type);
/** * This method generates <code>ValidationCaller</code>s for each method annotated * with <code>@SelfValidation</code> that adheres to required signature. */ @SuppressWarnings({ "rawtypes" }) private <T> List<ValidationCaller> findMethods(Class<T> annotated) { ResolvedTypeWithMembers annotatedType = memberResolver.resolve(typeResolver.resolve(annotated), annotationConfiguration, null); final List<ValidationCaller> callers = Arrays.stream(annotatedType.getMemberMethods()) .filter(this::isValidationMethod) .filter(this::isMethodCorrect) .map(m -> new ProxyValidationCaller<>(annotated, m)) .collect(Collectors.toList()); if (callers.isEmpty()) { log.warn("The class {} is annotated with @SelfValidating but contains no valid methods that are annotated " + "with @SelfValidation", annotated); } return callers; }
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)); }
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(); } }
/** * 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); }
public static ResolvedType mapValueType(ResolvedType type) { if (Map.class.isAssignableFrom(type.getErasedType())) { return mapValueType(type, Map.class); } else { return new TypeResolver().resolve(Object.class); } }
@Override public void resolveAllTypes(String className) { // the resolved type for the top level class in the hierarchy Class<?> clazz = classLoaderService.getValue().classForName( className ); ResolvedType resolvedType = typeResolver.resolve( clazz ); while ( resolvedType != null ) { // todo - check whether there is already something in the map resolvedTypeCache.put( clazz, resolvedType ); resolvedType = resolvedType.getParentClass(); if ( resolvedType != null ) { clazz = resolvedType.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();
@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 ); }
/** * 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); }
private void _addOverrides(List<HierarchicType> typesWithOverrides, Set<ClassKey> seenTypes, Class<?> override) { ClassKey key = new ClassKey(override); if (!seenTypes.contains(key)) { seenTypes.add(key); ResolvedType resolvedOverride = _typeResolver.resolve(override); typesWithOverrides.add(new HierarchicType(resolvedOverride, true, typesWithOverrides.size())); for (ResolvedType r : resolvedOverride.getImplementedInterfaces()) { // interfaces? _addOverrides(typesWithOverrides, seenTypes, r); } ResolvedType superClass = resolvedOverride.getParentClass(); _addOverrides(typesWithOverrides, seenTypes, superClass); } }
Integer contexArgIndex = null; for (int argIndex = 0; argIndex < parameterAnnotations.length; argIndex++) { ResolvedType resolvedType = new TypeResolver().resolve(parametersTypes[argIndex]); if (resolvedType.isInstanceOf(APIContext.class)) { contexArgIndex = argIndex; } else if (processPathParam(parameterAnnotations[argIndex],resolvedType,argumentIndexToRestParam,argIndex)) { } else{ bodyType = TypeLiteral.create(parametersTypes[argIndex]); argumentIndexToRestParam.put(argIndex,new RestBodyParam(new TypeResolver().resolve(parametersTypes[argIndex])));
ResolvedType attributeType = new TypeResolver().resolve(t); attributeDeserializer = serialization.getDeserializer(attrTypeHandler); ResolvedType objectType = new TypeResolver().resolve(attribute.getEffectiveObjectType()); ObjectTypeHandler objectTypeHandler = (ObjectTypeHandler) TypeHandler.lookup(objectType); if (!(objectTypeHandler instanceof ObjectTypeHandler)) { throw new RuntimeException("Index " + attribute.getAttributeName() + " is not an object, but " + objectType.getBriefDescription()); } else { objectSerializer = serialization.getSerializer(objectTypeHandler.getWrappedClass());
public CollectionHandler(JavaObjectTransformer transformer) { this.transformer = transformer; this.typeResolver = new TypeResolver(); }
public boolean hasSeenBefore(ResolvedType resolvedType) { return seenTypes.contains(resolvedType) || seenTypes.contains(asResolved(new TypeResolver(), resolvedType.getErasedType())) // DK TODO : fix // alternate types || parentHasSeenBefore(resolvedType); }
ResolvedType resolvedSubType = typeResolver.resolve(subTypeMethod.getDeclaringClass()); MemberResolver memberResolver = new MemberResolver(typeResolver); memberResolver.setMethodFilter(new SimpleMethodFilter(subTypeMethod, superTypeMethod)); if (!resolvedMethods[0].getArgumentType(i).equals(resolvedMethods[1].getArgumentType(i)))
static Type resolveReturnType(Type classType, Method method, Type... argTypes) { // this should resolve any class-level type variables Type returnType = TypeToken.of(classType) .resolveType(method.getGenericReturnType()).getType(); Type[] parameterTypes = method.getGenericParameterTypes(); TypeResolver resolver = new TypeResolver(); for (int i = 0; i < parameterTypes.length; i++) { @SuppressWarnings("unchecked") // necessary for getSupertype call to compile TypeToken<Object> paramType = (TypeToken<Object>) TypeToken.of(parameterTypes[i]); @SuppressWarnings("unchecked") // necessary for getSupertype call to compile TypeToken<Object> argType = (TypeToken<Object>) TypeToken.of(argTypes[i]); if (method.isVarArgs() && i == parameterTypes.length - 1) { // TODO } else { TypeToken<?> argTypeAsParamType = argType.getSupertype(paramType.getRawType()); resolver = resolver.where( paramType.getType(), argTypeAsParamType.getType()); } } return resolver.resolveType(returnType); }
type = _constructType(context, rawType, typeBindings); } else { type = _resolvedTypes.find(key); if (type == null) { type = _constructType(context, rawType, typeBindings); _resolvedTypes.put(key, type);