public List<ConstructorMetadata> matches( final List<MemberHoldingTypeDetails> memberHoldingTypeDetailsList) { final List<ConstructorMetadata> constructors = new ArrayList<ConstructorMetadata>(); for (final MemberHoldingTypeDetails memberHoldingTypeDetails : memberHoldingTypeDetailsList) { for (final ConstructorMetadata constructor : memberHoldingTypeDetails .getDeclaredConstructors()) { if (parameterTypes.equals(AnnotatedJavaType.convertFromAnnotatedJavaTypes(constructor .getParameterTypes()))) { constructors.add(constructor); } } } return constructors; } }
public ConstructorMetadata getDeclaredConstructor(final List<JavaType> parameters) { final Collection<JavaType> parameterList = CollectionUtils.populate(new ArrayList<JavaType>(), parameters); for (final ConstructorMetadata constructor : getDeclaredConstructors()) { if (parameterList.equals(AnnotatedJavaType.convertFromAnnotatedJavaTypes(constructor .getParameterTypes()))) { return constructor; } } return null; }
@Override public boolean matchSignature(MethodMetadata otherMethod) { if (methodName.getSymbolName().equals(otherMethod.getMethodName().getSymbolName())) { if (otherMethod.getParameterTypes().size() == getParameterTypes().size()) { List<JavaType> params = AnnotatedJavaType.convertFromAnnotatedJavaTypes(this.getParameterTypes()); List<JavaType> paramsOther = AnnotatedJavaType.convertFromAnnotatedJavaTypes(otherMethod.getParameterTypes()); boolean parametersEquals = true; for (int i = 0; i < params.size(); i++) { if (!params.get(i).equals(paramsOther.get(i))) { parametersEquals = false; } } if (parametersEquals) { return true; } } } return false; }
/** * Ensures that the governor has provided constructor * * @param ConstructorMetadataBuilder the constructor to include(required) * @since 2.0 */ protected final void ensureGovernorHasConstructor( final ConstructorMetadataBuilder constructorMetadata) { if (governorTypeDetails.getDeclaredConstructor(AnnotatedJavaType .convertFromAnnotatedJavaTypes(constructorMetadata.getParameterTypes())) == null) { builder.addConstructor(constructorMetadata); } }
private MethodMetadata getFindOneMethod(JavaType entity, FieldMetadata identifierFieldMetadata) { // Define method parameter type and name List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterTypes .add(AnnotatedJavaType.convertFromJavaType(identifierFieldMetadata.getFieldType())); parameterNames.add(identifierFieldMetadata.getFieldName()); MethodMetadata existingMethod = getGovernorMethod(FIND_ONE_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata return new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, FIND_ONE_METHOD_NAME, entity, parameterTypes, parameterNames, null).build(); }
public void addDataToConstructor(final ConstructorMetadata replacement, final CustomData customData) { // If the MIDs don't match then the proposed can't be a replacement if (!replacement.getDeclaredByMetadataId().equals(getDeclaredByMetadataId())) { return; } for (final ConstructorMetadataBuilder existingConstructor : getDeclaredConstructors()) { if (AnnotatedJavaType .convertFromAnnotatedJavaTypes(existingConstructor.getParameterTypes()).equals( AnnotatedJavaType.convertFromAnnotatedJavaTypes(replacement.getParameterTypes()))) { for (final Object key : customData.keySet()) { existingConstructor.putCustomData(key, customData.get(key)); } break; } } }
private MethodMetadata getSaveMethod(JavaType entity) { // Define method parameter type and name List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(entity)); parameterNames.add(new JavaSymbolName(StringUtils.uncapitalize(entity.getSimpleTypeName()))); MethodMetadata existingMethod = getGovernorMethod(SAVE_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata return new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, SAVE_METHOD_NAME, entity, parameterTypes, parameterNames, null).build(); }
@Override protected void onAddConstructor(final ConstructorMetadataBuilder md) { Validate.isTrue(governor.getDeclaredConstructor(AnnotatedJavaType .convertFromAnnotatedJavaTypes(md.getParameterTypes())) == null, "Constructor with %d parameters already defined in target type '%s' (ITD target '%s')", md .getParameterTypes().size(), governor.getName().getFullyQualifiedTypeName(), aspect .getFullyQualifiedTypeName()); Validate.isTrue( build().getDeclaredConstructor( AnnotatedJavaType.convertFromAnnotatedJavaTypes(md.getParameterTypes())) == null, "Constructor with %d parameters already defined in ITD (ITD target '%s')", md .getParameterTypes().size(), aspect.getFullyQualifiedTypeName()); Validate .notBlank( md.getBody(), "Constructor '%s' failed to provide a body, despite being identified for ITD inclusion", md); }
/** * Method that generates method "count". * * @return MethodMetadataBuilder with public long count(); * structure */ private MethodMetadata getCountMethod() { // Define method name JavaSymbolName methodName = new JavaSymbolName("count"); // Define method parameter types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); // Define method parameter names List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, JavaType.LONG_PRIMITIVE, parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
private MethodMetadata getFindAllIteratorMethod(JavaType entity, FieldMetadata identifierFieldMetadata) { // Define method parameter type and name List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); parameterTypes.add(AnnotatedJavaType.convertFromJavaType(JavaType .iterableOf(identifierFieldMetadata.getFieldType()))); parameterNames.add(identifierFieldMetadata.getFieldName()); MethodMetadata existingMethod = getGovernorMethod(FIND_ALL_ITERATOR_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata return new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, FIND_ALL_ITERATOR_METHOD_NAME, JavaType.listOf(entity), parameterTypes, parameterNames, null).build(); }
public void addDataToMethod(final MethodMetadata replacement, final CustomData customData) { // If the MIDs don't match then the proposed can't be a replacement if (!replacement.getDeclaredByMetadataId().equals(getDeclaredByMetadataId())) { return; } for (final MethodMetadataBuilder existingMethod : getDeclaredMethods()) { if (existingMethod.getMethodName().equals(replacement.getMethodName())) { if (AnnotatedJavaType.convertFromAnnotatedJavaTypes(existingMethod.getParameterTypes()) .equals( AnnotatedJavaType.convertFromAnnotatedJavaTypes(replacement.getParameterTypes()))) { for (final Object key : customData.keySet()) { existingMethod.putCustomData(key, customData.get(key)); } break; } } } }
private void doModification(final ConstructorMetadata constructor, final CustomData customData) { final MemberHoldingTypeDetails memberHoldingTypeDetails = memberHoldingTypeDetailsMap.get(constructor.getDeclaredByMetadataId()); if (memberHoldingTypeDetails != null) { final ConstructorMetadata matchedConstructor = memberHoldingTypeDetails.getDeclaredConstructor(AnnotatedJavaType .convertFromAnnotatedJavaTypes(constructor.getParameterTypes())); if (matchedConstructor != null && !matchedConstructor.getCustomData().keySet().containsAll(customData.keySet())) { final TypeDetailsBuilder typeDetailsBuilder = getTypeDetailsBuilder(memberHoldingTypeDetails); typeDetailsBuilder.addDataToConstructor(constructor, customData); changed = true; } } }
/** * Ensures that the governor has provided method * * @param MethodMetadataBuilder the method to include(required) * @since 2.0 */ protected final void ensureGovernorHasMethod(final MethodMetadataBuilder methodMetadata) { if (!hasToExcludeMethod(methodMetadata) && governorTypeDetails.getMethod(methodMetadata.getMethodName(), AnnotatedJavaType.convertFromAnnotatedJavaTypes(methodMetadata.getParameterTypes())) == null && methodMetadata.getDeclaredByMetadataId().equals(getId()) && MemberFindingUtils.getDeclaredMethod(builder.build(), methodMetadata.getMethodName(), AnnotatedJavaType.convertFromAnnotatedJavaTypes(methodMetadata.getParameterTypes())) == null) { builder.addMethod(methodMetadata); } }
@Override protected void onAddMethod(final MethodMetadataBuilder md) { Validate.isTrue( MemberFindingUtils.getDeclaredMethod(governor, md.getMethodName(), AnnotatedJavaType.convertFromAnnotatedJavaTypes(md.getParameterTypes())) == null, "Method '%s' already defined in target type '%s' (ITD target '%s')", md.getMethodName(), governor.getName().getFullyQualifiedTypeName(), aspect.getFullyQualifiedTypeName()); Validate.isTrue( MemberFindingUtils.getDeclaredMethod(build(), md.getMethodName(), AnnotatedJavaType.convertFromAnnotatedJavaTypes(md.getParameterTypes())) == null, "Method '%s' already defined in ITD (ITD target '%s')", md.getMethodName(), aspect.getFullyQualifiedTypeName()); if (!Modifier.isAbstract(md.getModifier()) && md.getReturnType() != JavaType.VOID_PRIMITIVE) { Validate.notBlank(md.getBody(), "Method '%s' failed to provide a body, despite being identified for ITD inclusion", md); } } }
private void doModification(final MethodMetadata method, final CustomData customData) { final MemberHoldingTypeDetails memberHoldingTypeDetails = memberHoldingTypeDetailsMap.get(method.getDeclaredByMetadataId()); if (memberHoldingTypeDetails != null) { final MethodMetadata matchedMethod = memberHoldingTypeDetails.getMethod(method.getMethodName(), AnnotatedJavaType.convertFromAnnotatedJavaTypes(method.getParameterTypes())); if (matchedMethod != null && !matchedMethod.getCustomData().keySet().containsAll(customData.keySet())) { final TypeDetailsBuilder typeDetailsBuilder = getTypeDetailsBuilder(memberHoldingTypeDetails); typeDetailsBuilder.addDataToMethod(method, customData); changed = true; } } }
/** * Builds a method which returns the class of entity JavaType. * * @return MethodMetadataBuilder */ private MethodMetadata getEntityTypeGetterMethod() { List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); MethodMetadata existingMethod = getGovernorMethod(GET_ENTITY_TYPE_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); // return ENTITY_TYPE.class; bodyBuilder.appendFormalLine("return %s.class;", this.entity.getNameIncludingTypeParameters(false, importResolver)); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, GET_ENTITY_TYPE_METHOD_NAME, JavaType.wrapperOf(JavaType.CLASS, this.entity), parameterTypes, parameterNames, bodyBuilder); // Build and return a MethodMetadata instance return methodBuilder.build(); }
/** * Builds a method which returns the class of the entity identifier JavaType. * * @return MethodMetadataBuilder */ private MethodMetadata getIdentifierTypeGetterMethod() { List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); MethodMetadata existingMethod = getGovernorMethod(GET_ID_TYPE_METHOD_NAME, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); // return IDENTIFIER_TYPE.class; bodyBuilder.appendFormalLine("return %s.class;", getNameOfJavaType(this.entityIdentifierType)); // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, GET_ID_TYPE_METHOD_NAME, JavaType.wrapperOf(JavaType.CLASS, this.serviceMetadata.getIdType()), parameterTypes, parameterNames, bodyBuilder); // Build and return a MethodMetadata instance return methodBuilder.build(); }
private MethodMetadata getControllerClassMethod() { // Define methodName final JavaSymbolName methodName = GET_CONTROLLER_CLASS_METHOD_NAME; // Define method argument types List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); // Return method if already exists MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine("return %s.class;", getNameOfJavaType(this.controller)); // return CONTROLLER_CLASS; MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC, methodName, JavaType.wrapperOf( JavaType.CLASS, this.controller), null); // Set method body methodBuilder.setBodyBuilder(bodyBuilder); return methodBuilder.build(); }
/** * Method that generates method "findAll" method. This method includes * GlobalSearch parameters to be able to filter results. * * @return MethodMetadata */ private MethodMetadata getFindAllByIdsInGlobalSearchMethod() { // Define method name JavaSymbolName methodName = this.findAllByIdsInGlobalSearchMethod.getMethodName(); // Define method parameter types List<AnnotatedJavaType> parameterTypes = this.findAllByIdsInGlobalSearchMethod.getParameterTypes(); // Define method parameter names List<JavaSymbolName> parameterNames = this.findAllByIdsInGlobalSearchMethod.getParameterNames(); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, this.findAllByIdsInGlobalSearchMethod.getReturnType(), parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
/** * Method that generates method "findAll" method. This method includes * GlobalSearch parameters to be able to filter results. * * @return MethodMetadata */ private MethodMetadata getFindAllGlobalSearchMethod() { // Define method name JavaSymbolName methodName = this.findAllGlobalSearchMethod.getMethodName(); // Define method parameter types List<AnnotatedJavaType> parameterTypes = this.findAllGlobalSearchMethod.getParameterTypes(); // Define method parameter names List<JavaSymbolName> parameterNames = this.findAllGlobalSearchMethod.getParameterNames(); MethodMetadata existingMethod = getGovernorMethod(methodName, AnnotatedJavaType.convertFromAnnotatedJavaTypes(parameterTypes)); if (existingMethod != null) { return existingMethod; } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, methodName, this.findAllGlobalSearchMethod.getReturnType(), parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }