public boolean hasSameName(final MethodMetadata... otherMethods) { for (final MethodMetadata otherMethod : otherMethods) { if (otherMethod != null && methodName.equals(otherMethod.getMethodName())) { return true; } } return false; }
public FieldMetadata getDeclaredField(final JavaSymbolName fieldName) { for (final FieldMetadata field : getDeclaredFields()) { if (field.getFieldName().equals(fieldName)) { return field; } } return null; }
private boolean hasField(final List<? extends FieldMetadata> declaredFields, final FieldMetadata idField) { for (final FieldMetadata declaredField : declaredFields) { if (declaredField.getFieldName().equals(idField.getFieldName())) { return true; } } return false; }
/** * Locates all methods on the specified {@link MemberHoldingTypeDetails} based * on the method name. * * @param memberHoldingTypeDetails the {@link MemberHoldingTypeDetails} to * search; can be <code>null</code> * @param methodName to locate; can be <code>null</code> * @return the list of methods, or <code>null</code> if the given name was * <code>null</code> or it was simply not found */ public static List<MethodMetadata> getDeclaredMethods( final MemberHoldingTypeDetails memberHoldingTypeDetails, final JavaSymbolName methodName) { if (memberHoldingTypeDetails == null) { return null; } List<MethodMetadata> methods = new ArrayList<MethodMetadata>(); for (final MethodMetadata method : memberHoldingTypeDetails.getDeclaredMethods()) { if (method.getMethodName().equals(methodName)) { methods.add(method); } } if (!methods.isEmpty()) { return methods; } return null; }
return false; } else if (!fieldName.equals(other.fieldName)) { return false;
/** * Checks if entity has already a field with the same name and throws an exception * in that case. * * @param fieldName * @param isforce * @param javaTypeDetails * @param parameterName */ private void checkFieldExists(final JavaSymbolName fieldName, final boolean isForce, final ClassOrInterfaceTypeDetails javaTypeDetails, final String parameterName) { MemberDetails memberDetails = memberDetailsScanner.getMemberDetails(this.getClass().getName(), javaTypeDetails); List<FieldMetadata> fields = memberDetails.getFields(); for (FieldMetadata field : fields) { if (field.getFieldName().equals(fieldName) && !isForce) { throw new IllegalArgumentException( String .format( "Field '%s' already exists and cannot be created. Try to use a " + "different field name on --%s parameter or use --force parameter to overwrite it.", fieldName, parameterName)); } } }
/** * Locates a method on the specified {@link MemberHoldingTypeDetails} based * on the method name. * * @param memberHoldingTypeDetails the {@link MemberHoldingTypeDetails} to * search; can be <code>null</code> * @param methodName to locate; can be <code>null</code> * @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) { if (memberHoldingTypeDetails == null) { return null; } for (final MethodMetadata method : memberHoldingTypeDetails.getDeclaredMethods()) { if (method.getMethodName().equals(methodName)) { return method; } } return null; }
/** * Checks if entity has already a field with the same name and throws an exception * in that case. * * @param fieldName * @param shellContext * @param javaTypeDetails * * @deprecated this should be done by operation class (see JpaFieldCreatorProvider.checkFieldExists) */ private void checkFieldExists(final JavaSymbolName fieldName, ShellContext shellContext, final ClassOrInterfaceTypeDetails javaTypeDetails) { MemberDetails memberDetails = memberDetailsScanner.getMemberDetails(this.getClass().getName(), javaTypeDetails); List<FieldMetadata> fields = memberDetails.getFields(); for (FieldMetadata field : fields) { if (field.getFieldName().equals(fieldName) && !shellContext.isForce()) { throw new IllegalArgumentException( String .format( "Field '%s' already exists and cannot be created. Try to use a " + "different field name on --fieldName parameter or use --force parameter to overwrite it.", fieldName)); } } }
matchTypes = true; if (!current.getMethodName().equals(metadataToRemove.getMethodName())) { continue;
if (method.getMethodName().equals(new JavaSymbolName(name))) { List<AnnotatedJavaType> methodParams = method.getParameterTypes(); boolean sameParameterTypes = false;
/** * 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; }
@Override public boolean equals(final Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof AbstractAnnotationAttributeValue<?>)) { return false; } final AbstractAnnotationAttributeValue<?> other = (AbstractAnnotationAttributeValue<?>) obj; if (getValue() == null) { if (other.getValue() != null) { return false; } } else if (!getValue().equals(other.getValue())) { return false; } if (name == null) { if (other.name != null) { return false; } } else if (!name.equals(other.name)) { return false; } return true; }
/** * To check if current method was implemented on all Java classes or ITds * associated to this entity class. * If method was implemented, is not necessary to add again. * * @param methodBuilder * @return */ private boolean checkIfInterfaceMethodWasImplemented(MethodMetadataBuilder methodBuilder) { // ROO-3584: Obtain current declared methods List<MethodMetadataBuilder> declaredMethods = builder.getDeclaredMethods(); for (MethodMetadataBuilder method : declaredMethods) { // If current method equals to interface method, return false if (method.getMethodName().equals(methodBuilder.getMethodName())) { return true; } } // ROO-3587: Obtain ALL declared methods from Java classes and ITDs. MemberDetails memberDetails = memberDetailsScanner.getMemberDetails(getClass().getName(), governorTypeDetails); List<MethodMetadata> allMethods = memberDetails.getMethods(); for (MethodMetadata method : allMethods) { // If current method equals to interface method, return false if (method.getMethodName().equals(methodBuilder.getMethodName())) { return true; } } return false; }
public List<FieldMetadata> getToStringFields( final PhysicalTypeMetadata governorPhysicalTypeMetadata, final List<FieldMetadata> declaredFields) { ClassOrInterfaceTypeDetails superclass = governorPhysicalTypeMetadata.getMemberHoldingTypeDetails().getSuperclass(); List<FieldMetadata> toStringFields = new ArrayList<FieldMetadata>(); if (superclass != null && superclass != JavaType.OBJECT) { List<FieldMetadata> superclassFields = getMemberDetailsScanner().getMemberDetails(this.getClass().getName(), superclass) .getFields(); for (FieldMetadata field : declaredFields) { boolean alreadyInSuperclass = false; for (FieldMetadata superclassField : superclassFields) { if (superclassField.getDeclaredByMetadataId().equals(field.getDeclaredByMetadataId()) && superclassField.getFieldName().equals(field.getFieldName())) { alreadyInSuperclass = true; break; } } if (!alreadyInSuperclass) { toStringFields.add(field); } } } else { toStringFields.addAll(declaredFields); } return toStringFields; }
public void addDataToField(final FieldMetadata 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 FieldMetadataBuilder existingField : getDeclaredFields()) { if (existingField.getFieldName().equals(replacement.getFieldName())) { for (final Object key : customData.keySet()) { existingField.putCustomData(key, customData.get(key)); } break; } } }
continue; if (versionField != null && field.getFieldName().equals(versionField.getFieldName())) { continue;
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; } } } }
getTypeLocationService().getTypeDetails(currentEntity)).getFields(); for (FieldMetadata relatedField : relatedEntityFields) { if (relatedField.getFieldName().equals(finderFieldName) && relatedField.getFieldType().equals(finderFieldType)) { if (dtoField.getFieldName().equals(finderFieldName) && dtoField.getFieldType().equals(finderFieldType)) { fieldMetadataMap.put(finderFieldName.getSymbolName(), dtoField);
/** * Builds constructor for initializing <code>final</code> fields. * * @return ConstructorMetadataBuilder for adding constructor to ITD */ private ConstructorMetadataBuilder getConstructor() { ConstructorMetadataBuilder constructorBuilder = new ConstructorMetadataBuilder(getId()); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); for (FieldMetadata field : fields) { // Add all fields excluding Serializable field if (!field.getFieldName().equals(serialField)) { String fieldName = field.getFieldName().getSymbolName(); constructorBuilder.addParameter(fieldName, field.getFieldType()); bodyBuilder.appendFormalLine(String.format("this.%s = %s;", fieldName, fieldName)); } } constructorBuilder.setModifier(Modifier.PUBLIC); constructorBuilder.setBodyBuilder(bodyBuilder); return constructorBuilder; }
/** * Builds constructor for initializing <code>final</code> fields. * * @return ConstructorMetadataBuilder for adding constructor to ITD */ private ConstructorMetadataBuilder getConstructor() { ConstructorMetadataBuilder constructorBuilder = new ConstructorMetadataBuilder(getId()); InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder(); if (annotationValues.getImmutable() == true) { for (FieldMetadata field : fields) { // Add all fields excluding Serializable field if (!field.getFieldName().equals(serialField)) { String fieldName = field.getFieldName().getSymbolName(); constructorBuilder.addParameter(fieldName, field.getFieldType()); bodyBuilder.appendFormalLine(String.format("this.%s = %s;", fieldName, fieldName)); } } } constructorBuilder.setModifier(Modifier.PUBLIC); constructorBuilder.setBodyBuilder(bodyBuilder); return constructorBuilder; }