Refine search
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; }
if ( member instanceof Method ) { for ( ResolvedMethod resolvedMember : declaringClassWithMembers.getMemberMethods() ) { if ( resolvedMember.getName().equals( member.getName() ) ) { return resolvedMember;
@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()); } } }
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; } }
for (int i = 0; i < resolvedMethods[0].getArgumentCount(); i++) if (!resolvedMethods[0].getArgumentType(i).equals(resolvedMethods[1].getArgumentType(i)))
@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 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(); }
static ResultReturnThing forType(ResolvedMethod method) { ResolvedType return_type = method.getReturnType(); if (return_type == null) { throw new IllegalStateException(String.format( "Method %s#%s is annotated as if it should return a value, but the method is void.", method.getDeclaringType().getErasedType().getName(), method.getName())); } else if (return_type.isInstanceOf(ResultBearing.class)) { return new ResultBearingResultReturnThing(method); } else if (return_type.isInstanceOf(Iterable.class)) { return new IterableReturningThing(method); } else if (return_type.isInstanceOf(Iterator.class)) { return new IteratorResultReturnThing(method); } else { return new SingleValueResultReturnThing(method); } }
@Override public Iterable<? extends ModelProperty> propertiesForSerialization(ResolvedType resolvedType) { List<ModelProperty> serializationCandidates = newArrayList(); SerializationConfig serializationConfig = objectMapper.getSerializationConfig(); BeanDescription beanDescription = serializationConfig.introspect(TypeFactory.defaultInstance() .constructType(resolvedType.getErasedType())); Map<String, BeanPropertyDefinition> propertyLookup = uniqueIndex(beanDescription.findProperties(), BeanPropertyDefinitions.beanPropertyByInternalName()); for (ResolvedMethod childProperty : accessors.in(resolvedType)) { if (propertyLookup.containsKey(propertyName(childProperty.getName()))) { BeanPropertyDefinition propertyDefinition = propertyLookup.get(propertyName(childProperty.getName())); Optional<BeanPropertyDefinition> jacksonProperty = jacksonPropertyWithSameInternalName(beanDescription, propertyDefinition); AnnotatedMember member = propertyDefinition.getPrimaryMember(); if (accessorMemberIs(childProperty, methodName(member))) { serializationCandidates.add(beanModelProperty(childProperty, jacksonProperty, true)); } } } return serializationCandidates; }
@Override public void call(ViolationCollector vc) { final Method method = resolvedMethod.getRawMember(); final T obj = cls.cast(getValidationObject()); try { method.invoke(obj, vc); } catch (ReflectiveOperationException e) { throw new IllegalStateException("Couldn't call " + resolvedMethod + " on " + getValidationObject(), e); } } }
@VisibleForTesting List<ModelProperty> addCandidateProperties(AnnotatedMember member, ResolvedMethod childProperty, Optional<BeanPropertyDefinition> jacksonProperty, ModelContext givenContext) { if (member instanceof AnnotatedMethod && memberIsUnwrapped(member)) { if (Accessors.isGetter(((AnnotatedMethod) member).getMember())) { return propertiesFor(childProperty.getReturnType(), fromParent(givenContext, childProperty.getReturnType())); } else { return propertiesFor(childProperty.getArgumentType(0), fromParent(givenContext, childProperty.getArgumentType(0))); } } else { return newArrayList(beanModelProperty(childProperty, jacksonProperty, givenContext)); } }
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 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) { return input.getArgumentCount() == methodToResolve.getParameterTypes().length; } });
@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; } }
CallHandler(Class<?> sqlObjectType, ResolvedMethod method) { super(sqlObjectType, method); if (null != method.getReturnType() ) { if (method.getReturnType().isInstanceOf(OutParameters.class)){ returnOutParams = true; } else { throw new IllegalArgumentException("@SqlCall methods may only return null or OutParameters at present"); } } else { returnOutParams = false; } this.sql = SqlObject.getSql(method.getRawMember().getAnnotation(SqlCall.class), method.getRawMember()); }
private ResolvedType returnTypeOrVoid(ResolvedMethod input) { ResolvedType returnType = input.getReturnType(); if (returnType == null) { returnType = typeResolver.resolve(Void.class); } return returnType; }
final Method raw_method = method.getRawMember(); handlers.put(raw_method, new CreateSqlObjectHandler(raw_method.getReturnType())); else if (method.getName().equals("close") && method.getRawMember().getParameterTypes().length == 0) { handlers.put(raw_method, new CloseHandler());
public ResolvedType getReturnType() { return getType(); }
@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()); } } }