/** * 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 List<ResolvedMethod> getMemberMethods( Class hostClass) { if(!methodsResolvedForHostClasses.containsKey(hostClass)) { ResolvedType beanType = typeResolver.resolve(hostClass); MemberResolver resolver = new MemberResolver(typeResolver); resolver.setIncludeLangObject(false); ResolvedTypeWithMembers typeWithMembers = resolver.resolve(beanType, null, null); methodsResolvedForHostClasses.put(hostClass, newArrayList(typeWithMembers.getMemberMethods())); } return methodsResolvedForHostClasses.get(hostClass); }
@Override public ResolvedTypeWithMembers resolveMemberTypes(ResolvedType type) { // todo : is there a reason we create this resolver every time? MemberResolver memberResolver = new MemberResolver( typeResolver ); return memberResolver.resolve( type, null, null ); }
MemberResolver memberResolver = new MemberResolver(typeResolver); memberResolver.setMethodFilter(new SimpleMethodFilter(subTypeMethod, superTypeMethod)); final ResolvedTypeWithMembers typeWithMembers = memberResolver.resolve(resolvedSubType, null, null); ResolvedMethod[] resolvedMethods = new ResolvedMethod[0]; try {
public ReflectionHandler(JavaObjectTransformer transformer) { this.transformer = transformer; this.typeResolver = new TypeResolver(); this.memberResolver = new MemberResolver(typeResolver); memberResolver.setFieldFilter((f) -> { return f.isPublic() && !f.isStatic(); }); }
public com.google.common.collect.ImmutableList<ResolvedMethod> in(ResolvedType resolvedType) { MemberResolver resolver = new MemberResolver(typeResolver); resolver.setIncludeLangObject(false); if (resolvedType.getErasedType() == Object.class) { return ImmutableList.of(); } ResolvedTypeWithMembers typeWithMembers = resolver.resolve(resolvedType, null, null); return FluentIterable .from(newArrayList(typeWithMembers.getMemberMethods())) .filter(onlyGettersAndSetters()).toList(); } }
@Override public ResolvedTypeWithMembers resolveMemberTypes(ResolvedType type) { // todo : is there a reason we create this resolver every time? MemberResolver memberResolver = new MemberResolver( typeResolver ); return memberResolver.resolve( type, null, null ); }
MemberResolver memberResolver = new MemberResolver( typeResolver ); memberResolver.setMethodFilter( new SimpleMethodFilter( subTypeMethod, superTypeMethod ) ); ResolvedTypeWithMembers typeWithMembers = memberResolver.resolve( resolvedSubType, null,
public com.google.common.collect.ImmutableList<ResolvedMethod> in(ResolvedType resolvedType) { MemberResolver resolver = new MemberResolver(typeResolver); resolver.setIncludeLangObject(false); if (resolvedType.getErasedType() == Object.class) { return ImmutableList.of(); } ResolvedTypeWithMembers typeWithMembers = resolver.resolve(resolvedType, null, null); return FluentIterable .from(newArrayList(typeWithMembers.getMemberMethods())) .filter(onlyGettersAndSetters()).toList(); } }
public Iterable<? extends ResolvedField> in(ResolvedType resolvedType) { MemberResolver memberResolver = new MemberResolver(typeResolver); if (resolvedType.getErasedType() == Object.class) { return newArrayList(); } ResolvedTypeWithMembers resolvedMemberWithMembers = memberResolver.resolve(resolvedType, null, null); return newArrayList(resolvedMemberWithMembers.getMemberFields()); } }
MemberResolver memberResolver = new MemberResolver( typeResolver ); memberResolver.setMethodFilter( new SimpleMethodFilter( subTypeMethod, superTypeMethod ) ); ResolvedTypeWithMembers typeWithMembers = memberResolver.resolve( resolvedSubType, null,
reflectionManager.toClass( xProperty.getDeclaringClass() ) ); final ResolvedTypeWithMembers declaringClassWithMembers = classmateContext.getMemberResolver().resolve( declaringClassType, null,
public com.google.common.collect.ImmutableList<ResolvedMethod> in(ResolvedType resolvedType) { MemberResolver resolver = new MemberResolver(typeResolver); resolver.setIncludeLangObject(false); if (resolvedType.getErasedType() == Object.class) { return ImmutableList.of(); } ResolvedTypeWithMembers typeWithMembers = resolver.resolve(resolvedType, null, null); return FluentIterable .from(newArrayList(typeWithMembers.getMemberMethods())) .filter(onlyGettersAndSetters()).toList(); } }
public Iterable<? extends ResolvedField> in(ResolvedType resolvedType) { MemberResolver memberResolver = new MemberResolver(typeResolver); if (resolvedType.getErasedType() == Object.class) { return newArrayList(); } ResolvedTypeWithMembers resolvedMemberWithMembers = memberResolver.resolve(resolvedType, null, null); return newArrayList(resolvedMemberWithMembers.getMemberFields()); } }
private Map<String, ResolvedField> resolveFields(Class<?> targetType, Class<?>... parameterTypes) { ResolvedType resolvedType = typeResolver.resolve(targetType, parameterTypes); ResolvedTypeWithMembers resolvedTypeWithMembers = memberResolver.resolve(resolvedType, null, null); ResolvedField[] fields = resolvedTypeWithMembers.getMemberFields(); Map<String, ResolvedField> fieldMap = new LinkedHashMap<>(); for (ResolvedField field : fields) { fieldMap.put(field.getName(), field); } return fieldMap; }
/** * Finds the constructors in the given type * * @param resolvedType the type to search */ public com.google.common.collect.ImmutableList<ResolvedConstructor> constructorsIn(ResolvedType resolvedType) { MemberResolver resolver = new MemberResolver(typeResolver); resolver.setIncludeLangObject(false); if (resolvedType.getErasedType() == Object.class) { return ImmutableList.of(); } ResolvedTypeWithMembers typeWithMembers = resolver.resolve(resolvedType, null, null); return FluentIterable .from(newArrayList(typeWithMembers.getConstructors())).toList(); } }
public Iterable<? extends ResolvedField> in(ResolvedType resolvedType) { MemberResolver memberResolver = new MemberResolver(typeResolver); if (resolvedType.getErasedType() == Object.class) { return newArrayList(); } ResolvedTypeWithMembers resolvedMemberWithMembers = memberResolver.resolve(resolvedType, null, null); return newArrayList(resolvedMemberWithMembers.getMemberFields()); } }
TypeResolver typeResolver = new TypeResolver(); MemberResolver memberResolver = new MemberResolver(typeResolver); ResolvedType type = typeResolver.resolve(ITestDouble.class); ResolvedTypeWithMembers members = memberResolver.resolve(type, null, null); ResolvedMethod[] methods = members.getMemberMethods();
private ResolvedMethod getResolvedMethod(final Method methodToResolve, Class<?> beanType) { ResolvedType enclosingType = typeResolver.resolve(beanType); MemberResolver resolver = new MemberResolver(typeResolver); resolver.setIncludeLangObject(false); ResolvedTypeWithMembers typeWithMembers = resolver.resolve(enclosingType, null, null); Iterable<ResolvedMethod> filtered = filter(newArrayList(typeWithMembers.getMemberMethods()), methodNamesAreSame(methodToResolve)); return resolveToMethodWithMaxResolvedTypes(filtered, methodToResolve); }
final MemberResolver mr = new MemberResolver(typeResolver); final ResolvedType sql_object_type = typeResolver.resolve(sqlObjectType); final ResolvedTypeWithMembers d = mr.resolve(sql_object_type, null, null);