public SimpleTypeInfo returnTypeInfo() { return methodInfo.returnTypeInfo(); }
@Override public void compilationError(String message) { methodInfo.compilationError(message); }
public FieldInfo toFieldInfo() { return CoreFieldInfo.of(returnTypeInfo(), fieldName()); }
public String fieldName() { String prefix = getterPrefix(); String field = name().replace(prefix, ""); return Code.lowerCaseFirstChar(field); }
public MethodInfoMethodSpecWriter(MethodInfo methodInfo) { this.methodInfo = methodInfo; parameterList = methodInfo.parameterInfoList() .stream() .map(ParameterInfo::parameterSpec) .collect(Collectors.toList()); accessInfo = methodInfo.accessInfo(); returnTypeName = methodInfo .returnTypeInfo() .typeName(); }
public static Optional<SetterMethod> of(OrmPojoInfo pojoInfo, MethodInfo methodInfo) { AccessInfo accessInfo = methodInfo.accessInfo(); if (AccessInfo.PRIVATE.equals(accessInfo)) { methodInfo.compilationError("@Setter method must not be private."); return Optional.empty(); if (!methodInfo.hasModifierInfo(ModifierInfo.ABSTRACT)) { methodInfo.compilationError("@Setter method must be abstract."); return Optional.empty(); if (methodInfo.hasParameterInfoListSize(0)) { methodInfo.compilationError("@Setter method must have parameters"); return Optional.empty(); SimpleTypeInfo returnTypeInfo = methodInfo.returnTypeInfo(); Naming naming = pojoInfo.naming(); ClassName superClassName = naming.superClass(); if (!returnTypeInfo.className().equals(superClassName)) { methodInfo.compilationError("@Setter method must return %s", superClassName.simpleName()); return Optional.empty(); Map<OrmProperty, SetterParameter> parameterMap = methodInfo.parameterInfoStream() .map(param -> SetterParameter.of(pojoInfo, param)) .filter(Optional::isPresent) .collect(Collectors.toMap(SetterParameter::referencedProperty, Function.identity())); if (!methodInfo.hasParameterInfoListSize(parameterMap.size())) { return Optional.empty();
public static <T> Optional<T> of(MethodInfo methodInfo, Constructor<T> constructor) { if (!methodInfo.hasModifierInfo(ModifierInfo.ABSTRACT)) { methodInfo.compilationError("@Query method must be abstract"); return Optional.empty(); } if (methodInfo.hasAccessInfo(AccessInfo.PRIVATE)) { methodInfo.compilationError("@Query must not be private"); return Optional.empty(); } SimpleTypeInfo returnTypeInfo = methodInfo.returnTypeInfo(); QueryReturnType returnType = QueryReturnType.of(returnTypeInfo); TypeInfo pojoTypeInfo = returnType.pojoTypeInfo(returnTypeInfo); if (!pojoTypeInfo.hasAnnotation(Pojo.class)) { methodInfo.compilationError("@Query must return a List of, an Optional of or an instance of a @Pojo."); return Optional.empty(); } T method = constructor.apply(methodInfo, returnType, pojoTypeInfo); return Optional.of(method); }
@Override public Equality isEqualTo(Object that) { return Tester.of(MethodInfo.class) .add("name", o -> o.name()) .add("accessInfo", o -> o.accessInfo()) .add("modifierInfoSet", o -> o.modifierInfoSet()) .add("returnTypeInfo", o -> o.returnTypeInfo()) .add("annotationInfoList", o -> o.annotationInfoList()) .add("parameterInfoList", o -> o.parameterInfoList()) .test(this, that); }
private static List<Property> of0(Mode mode, TypeInfo typeInfo) { Naming naming = Naming.of(typeInfo); return typeInfo.methodInfoStream() .filter(m -> m.hasModifierInfo(ModifierInfo.ABSTRACT)) .filter(m -> !m.hasReturnTypeInfo(SimpleTypePrimitives.VOID)) .filter(m -> m.hasParameterInfoListSize(0)) .filter(m -> !m.hasAnnotation(Invalidate.class)) .map(m -> new Property(mode, naming, m)) .collect(MoreCollectors.toImmutableList()); }
void accept(TypeSpec.Builder type) { MethodInfoOverrideWriter writer = methodInfo.overrideWriter(); if (!methodInfo.hasModifierInfo(ModifierInfo.ABSTRACT)) { writer.addStatement("super.$L()", methodInfo.name()); } contributionList.forEach(contribution -> contribution.accept(writer)); if (self) { writer.addStatement("return this"); } type.addMethod(writer.write()); }
@Override public Contribution execute(PojoInfo pojoInfo) { return pojoInfo.methodInfoStream() .filter(m -> m.hasName("isEqualTo")) .filter(m -> m.hasParameterInfoListSize(1)) .filter(m -> m.hasModifierInfo(ModifierInfo.ABSTRACT)) .findFirst() .map(m -> execute0(pojoInfo)) .orElse(Contribution.empty()); }
private static Optional<CsvRecordMethod> of(MethodInfo methodInfo) { Optional<AnnotationInfo> maybeAt = methodInfo.annotationInfo(At.class); if (!maybeAt.isPresent()) { methodInfo.compilationError("@CsvRecord method must have an @At annotation."); return Optional.empty(); } CsvRecordMethod method = CsvRecordMethod.builder() .index(maybeAt.flatMap(ann -> ann.annotationValueInfo("value")) .get() .intValue()) .fieldName(methodInfo.fieldName()) .returnType(CsvRecordReturnType.of(methodInfo)) .build(); return Optional.of(method); }
public String accessorName() { return methodInfo.name(); }
@Override void accept(TypeSpec.Builder type) { MethodInfo methodInfo = property.methodInfo(); type.addMethod(methodInfo.overrideWriter() .addCode(body.build()) .write()); }
private String name() { return methodInfo.fieldName(); }
private String attributeName() { return methodInfo.annotationInfo(Attribute.class) .flatMap(ann -> ann.stringValue("name")) .orElse(methodInfo.name()); }
public Stream<ParameterInfo> parameterInfoStream() { return methodInfo.parameterInfoStream(); }
public boolean hasParameterInfoTypes(Class<?>... types) { Objects.requireNonNull(types); if (!hasParameterInfoListSize(types.length)) { return false; } int index = 0; Iterator<ParameterInfo> iterator = parameterInfoList().iterator(); while (iterator.hasNext()) { ParameterInfo parameterInfo = iterator.next(); Class<?> type = types[index++]; if (!parameterInfo.isInfoOf(type)) { return false; } } return true; }
String signature() { StringBuilder sig = new StringBuilder(); sig.append(name()); sig.append("("); Iterator<ParameterInfo> parameters = parameterInfoList().iterator(); if (parameters.hasNext()) { parameters.next().signature(sig); while (parameters.hasNext()) { sig.append(","); parameters.next().signature(sig); } } sig.append(")"); return sig.toString(); }