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; }
for (int i = 0; i < resolvedMethods[0].getArgumentCount(); i++)
@Override public boolean apply(ResolvedMethod input) { return input.getArgumentCount() == methodToResolve.getParameterTypes().length; } });
@Override public boolean apply(ResolvedMethod input) { return input.getArgumentCount() == methodToResolve.getParameterTypes().length; } });
@Override public boolean apply(ResolvedMethod input) { return input.getArgumentCount() == methodToResolve.getParameterTypes().length; } });
@Override public int compare(ResolvedMethod first, ResolvedMethod second) { return Ints.compare(first.getArgumentCount(), second.getArgumentCount()); } });
@Override public int compare(ResolvedMethod first, ResolvedMethod second) { return Ints.compare(first.getArgumentCount(), second.getArgumentCount()); } });
@Override public int compare(ResolvedMethod first, ResolvedMethod second) { return Ints.compare(first.getArgumentCount(), second.getArgumentCount()); } });
@Override public int compareTo(ResolvedMethod other) { // primary sort by name (alphabetic); secondary by arg count (ascending) int diff = getName().compareTo(other.getName()); if (diff == 0) { // subtract fine, no fear of overflow here diff = getArgumentCount() - other.getArgumentCount(); } return diff; } }
@Override public int compareTo(ResolvedMethod other) { // primary sort by name (alphabetic); secondary by arg count (ascending) int diff = getName().compareTo(other.getName()); if (diff == 0) { // subtract fine, no fear of overflow here diff = getArgumentCount() - other.getArgumentCount(); } return diff; } }
@Override public boolean apply(ResolvedMethod input) { for (int index = 0; index < input.getArgumentCount(); index++) { if (!covariant(input.getArgumentType(index), methodToResolve.getGenericParameterTypes()[index])) { return false; } } ResolvedType candidateMethodReturnValue = returnTypeOrVoid(input); return bothAreVoids(candidateMethodReturnValue, methodToResolve.getGenericReturnType()) || contravariant(candidateMethodReturnValue, methodToResolve.getGenericReturnType()); } };
@Override public List<ResolvedMethodParameter> apply(ResolvedMethod input) { List<ResolvedMethodParameter> parameters = newArrayList(); MethodParameter[] methodParameters = methodToResolve.getMethodParameters(); for (int i = 0; i < input.getArgumentCount(); i++) { parameters.add(new ResolvedMethodParameter( discoveredName(methodParameters[i]).or(String.format("param%s", i)), methodParameters[i], input.getArgumentType(i))); } return parameters; } };
public boolean canOverride(ResolvedMethod m1, ResolvedMethod m2) { if (!m1.getName().equals(m2.getName())) return false; int count = m1.getArgumentCount(); if (count != m2.getArgumentCount()) return false; for (int i = 0; i < count; i++) { if (!m1.getArgumentType(i).equals(m2.getArgumentType(i))) return false; } return true; }
@Override public boolean apply(ResolvedMethod input) { for (int index = 0; index < input.getArgumentCount(); index++) { if (!covariant(input.getArgumentType(index), methodToResolve.getGenericParameterTypes()[index])) { return false; } } ResolvedType candidateMethodReturnValue = returnTypeOrVoid(input); return bothAreVoids(candidateMethodReturnValue, methodToResolve.getGenericReturnType()) || contravariant(candidateMethodReturnValue, methodToResolve.getGenericReturnType()); } };
@Override public boolean apply(ResolvedMethod input) { for (int index = 0; index < input.getArgumentCount(); index++) { if (!covariant(input.getArgumentType(index), methodToResolve.getGenericParameterTypes()[index])) { return false; } } ResolvedType candidateMethodReturnValue = returnTypeOrVoid(input); return bothAreVoids(candidateMethodReturnValue, methodToResolve.getGenericReturnType()) || contravariant(candidateMethodReturnValue, methodToResolve.getGenericReturnType()); } };
public List<ResolvedMethodParameter> methodParameters(final HandlerMethod methodToResolve) { Class hostClass = use(methodToResolve.getBeanType()) .or(methodToResolve.getMethod().getDeclaringClass()); ResolvedMethod resolvedMethod = getResolvedMethod(methodToResolve.getMethod(), hostClass); List<ResolvedMethodParameter> parameters = newArrayList(); MethodParameter[] methodParameters = methodToResolve.getMethodParameters(); if (resolvedMethod != null) { if (methodParameters.length == resolvedMethod.getArgumentCount()) { for (int index = 0; index < resolvedMethod.getArgumentCount(); index++) { MethodParameter methodParameter = methodParameters[index]; methodParameter.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer()); parameters.add(new ResolvedMethodParameter(methodParameter, resolvedMethod.getArgumentType(index))); } } else { log.warn(String.format("Problem trying to resolve a method named %s", methodToResolve.getMethod().getName())); log.warn(String.format("Method parameter count %s does not match resolved method argument count %s", methodParameters.length, resolvedMethod.getArgumentCount())); } } return parameters; }
public List<ResolvedMethodParameter> methodParameters(final HandlerMethod methodToResolve) { Class hostClass = useType(methodToResolve.getBeanType()) .or(methodToResolve.getMethod().getDeclaringClass()); ResolvedMethod resolvedMethod = getResolvedMethod(methodToResolve.getMethod(), hostClass); List<ResolvedMethodParameter> parameters = newArrayList(); MethodParameter[] methodParameters = methodToResolve.getMethodParameters(); if (resolvedMethod != null) { if (methodParameters.length == resolvedMethod.getArgumentCount()) { for (int index = 0; index < resolvedMethod.getArgumentCount(); index++) { MethodParameter methodParameter = methodParameters[index]; methodParameter.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer()); parameters.add(new ResolvedMethodParameter(methodParameter, resolvedMethod.getArgumentType(index))); } } else { log.warn(String.format("Problem trying to resolve a method named %s", methodToResolve.getMethod().getName())); log.warn(String.format("Method parameter count %s does not match resolved method argument count %s", methodParameters.length, resolvedMethod.getArgumentCount())); } } return parameters; }
for ( int i = 0; i < resolvedMethods[0].getArgumentCount(); i++ ) { if ( !resolvedMethods[0].getArgumentType( i ) .equals( resolvedMethods[1].getArgumentType( i ) ) ) {
for ( int i = 0; i < resolvedMethods[0].getArgumentCount(); i++ ) { if ( !resolvedMethods[0].getArgumentType( i ) .equals( resolvedMethods[1].getArgumentType( i ) ) ) {