private JavaSymbolName getParameterNameFor(MethodMetadata method, JavaType type) { AnnotatedJavaType parameter; for (int i = 0; i < method.getParameterTypes().size(); i++) { parameter = method.getParameterTypes().get(i); if (parameter.getJavaType().equals(type)) { return method.getParameterNames().get(i); } } return null; }
/** * Indicates if the presented method compiles with the JavaBean conventions * around mutator methods (public, "set", 1 arg etc). * * @param method to evaluate (required) * @return true if the presented method is a mutator, otherwise false */ public static boolean isMutatorMethod(final MethodMetadata method) { Validate.notNull(method, "Method is required"); return method.getMethodName().getSymbolName().startsWith("set") && method.getParameterTypes().size() == 1 && Modifier.isPublic(method.getModifier()); }
/** * Indicates if the presented method compiles with the JavaBean conventions * around accessor methods (public, "set" or "is", 0 args etc). * * @param method to evaluate (required) * @return true if the presented method is an accessor, otherwise false */ public static boolean isAccessorMethod(final MethodMetadata method) { Validate.notNull(method, "Method is required"); return (method.getMethodName().getSymbolName().startsWith("get") || method.getMethodName() .getSymbolName().startsWith("is")) && method.getParameterTypes().isEmpty() && Modifier.isPublic(method.getModifier()); }
/** * Method that generates findAll method for provided referenced fields on current interface * * @param countMethod * @return */ private MethodMetadata getFindAllReferencedFieldMethod(MethodMetadata method) { // Define method parameter types and parameter names List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); List<AnnotatedJavaType> methodParamTypes = method.getParameterTypes(); List<JavaSymbolName> methodParamNames = method.getParameterNames(); for (int i = 0; i < method.getParameterTypes().size(); i++) { parameterTypes.add(methodParamTypes.get(i)); parameterNames.add(methodParamNames.get(i)); } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, method.getMethodName(), method.getReturnType(), parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
/** * Method that generates countByReferencedField method on current interface * * @param countMethod * @return */ private MethodMetadata getCountByReferencedFieldMethod(MethodMetadata countMethod) { // Define method parameter types and parameter names List<AnnotatedJavaType> parameterTypes = new ArrayList<AnnotatedJavaType>(); List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>(); List<AnnotatedJavaType> methodParamTypes = countMethod.getParameterTypes(); List<JavaSymbolName> methodParamNames = countMethod.getParameterNames(); for (int i = 0; i < countMethod.getParameterTypes().size(); i++) { parameterTypes.add(methodParamTypes.get(i)); parameterNames.add(methodParamNames.get(i)); } // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, countMethod.getMethodName(), countMethod.getReturnType(), parameterTypes, parameterNames, null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
/** * Check that the parameters of the method are equals of parameters list * * @param method Method to check * @param methodParametersToCompare Parameters to compare * @return true if are equals, false otherwise */ private boolean checkParameters(MethodMetadata method, List<?> methodParametersToCompare) { boolean parametersAreEquals = true; List<AnnotatedJavaType> parameterTypes = method.getParameterTypes(); if (methodParametersToCompare.size() != parameterTypes.size()) { parametersAreEquals = false; } else { for (int i = 0; i < methodParametersToCompare.size(); i++) { ClassAttributeValue methodParameterToCompare = (ClassAttributeValue) methodParametersToCompare.get(i); AnnotatedJavaType parameterJavaType = parameterTypes.get(i); if (!methodParameterToCompare.getValue().getSimpleTypeName() .equals(parameterJavaType.getJavaType().getSimpleTypeName())) { parametersAreEquals = false; break; } } } return parametersAreEquals; }
/** * Check that the parameters of the method are equals of parameters list * * @param method Method to check * @param methodParametersToCompare Parameters to compare * @return true if are equals, false otherwise */ private boolean checkParameters(MethodMetadata method, List<?> methodParametersToCompare) { boolean parametersAreEquals = true; List<AnnotatedJavaType> parameterTypes = method.getParameterTypes(); if (methodParametersToCompare.size() != parameterTypes.size()) { parametersAreEquals = false; } else { for (int i = 0; i < methodParametersToCompare.size(); i++) { ClassAttributeValue methodParameterToCompare = (ClassAttributeValue) methodParametersToCompare.get(i); AnnotatedJavaType parameterJavaType = parameterTypes.get(i); if (!methodParameterToCompare.getValue().getSimpleTypeName() .equals(parameterJavaType.getJavaType().getSimpleTypeName())) { parametersAreEquals = false; break; } } } return parametersAreEquals; }
@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; }
private void registerDependencyModulesOfFinder( final PhysicalTypeMetadata governorPhysicalTypeMetadata, MethodMetadata finder) { // Add dependencies between modules List<JavaType> types = new ArrayList<JavaType>(); types.add(finder.getReturnType()); types.addAll(finder.getReturnType().getParameters()); for (AnnotatedJavaType parameter : finder.getParameterTypes()) { types.add(parameter.getJavaType()); types.addAll(parameter.getJavaType().getParameters()); } for (JavaType parameter : types) { getTypeLocationService().addModuleDependency( governorPhysicalTypeMetadata.getType().getModule(), parameter); } }
/** * Locates the specified method. * * @param memberHoldingTypeDetails the {@link MemberHoldingTypeDetails} to * search; can be <code>null</code> * @param methodName to locate; can be <code>null</code> * @param parameters to locate (can be null if there are no parameters) * @return the method, or <code>null</code> if the given name was * <code>null</code> or it was simply not found */ public static MethodMetadata getDeclaredMethod( final MemberHoldingTypeDetails memberHoldingTypeDetails, final JavaSymbolName methodName, List<JavaType> parameters) { if (memberHoldingTypeDetails == null) { return null; } if (parameters == null) { parameters = new ArrayList<JavaType>(); } for (final MethodMetadata method : memberHoldingTypeDetails.getDeclaredMethods()) { if (method.getMethodName().equals(methodName)) { final List<JavaType> parameterTypes = AnnotatedJavaType.convertFromAnnotatedJavaTypes(method.getParameterTypes()); if (parameterTypes.equals(parameters)) { return method; } } } return null; }
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; } } }
/** * Method that generates custom count method. * * @return MethodMetadata */ private MethodMetadata getCustomCountMethod(MethodMetadata customCountMethod) { // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, customCountMethod.getMethodName(), customCountMethod.getReturnType(), customCountMethod.getParameterTypes(), customCountMethod.getParameterNames(), null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
/** * Method that generates finder method on current interface * * @param finderMethod * @return */ private MethodMetadata getFinderMethod(MethodMetadata finderMethod) { // Use the MethodMetadataBuilder for easy creation of MethodMetadata MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(getId(), Modifier.PUBLIC + Modifier.ABSTRACT, finderMethod.getMethodName(), finderMethod.getReturnType(), finderMethod.getParameterTypes(), finderMethod.getParameterNames(), null); return methodBuilder.build(); // Build and return a MethodMetadata // instance }
for (AnnotatedJavaType parameters : methodToBeImplemented.getParameterTypes()) { JavaType type = parameters.getJavaType(); isBatch = !type.getParameters().isEmpty();
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; } } } }
append(methodDetails.getMethodMetadata().getMethodName().getSymbolName()); append("("); for (int i = 0; i < methodDetails.getMethodMetadata().getParameterTypes().size(); i++) { append(methodDetails.getMethodMetadata().getParameterTypes().get(i).getJavaType() .getNameIncludingTypeParameters(false, resolver)); if (i != methodDetails.getMethodMetadata().getParameterTypes().size() - 1) { append(",");
final JavaSymbolName param1 = methodToBeImplemented.getParameterNames().get(1); final JavaType param1TypeWrapped = methodToBeImplemented.getParameterTypes().get(1).getJavaType().getParameters().get(0); final String saveMethod = serviceMetadata.getCurrentSaveMethod().getMethodName().getSymbolName();
/** * 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 }
/** * 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 }
/** * This method generates new method instance using an existing * methodMetadata * * @param declaredByMetadataId * @param method * * @return */ private MethodMetadata getNewMethod(String declaredByMetadataId, MethodMetadata method) { // Create bodyBuilder InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); bodyBuilder.appendFormalLine(method.getBody()); // Use the MethodMetadataBuilder for easy creation of MethodMetadata // based on existing method MethodMetadataBuilder methodBuilder = new MethodMetadataBuilder(declaredByMetadataId, method.getModifier(), method.getMethodName(), method.getReturnType(), method.getParameterTypes(), method.getParameterNames(), bodyBuilder); methodBuilder.setAnnotations(method.getAnnotations()); // ROO-3834: Including default comment structure during push-in methodBuilder.setCommentStructure(method.getCommentStructure()); return methodBuilder.build(); }