Examples with ConstructorMetadata org.springframework.roo.classpath.details.ConstructorMetadata used on opensource projects

Example 1 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class PushInOperationsImpl method pushInClass.

/**
 * Makes push-in of all items defined on a provided class
 *
 * @param klass
 *            class to make the push-in operation
 * @param weiteOnDisk
 *            indicates if pushed elements should be writed on .java file
 * @param force
 *            if some operation will produce several changes, this parameter
 *            should be true.
 *
 * @return list of objects with all the pushed elements.
 */
public List<Object> pushInClass(JavaType klass, boolean writeOnDisk, boolean force) {
    List<Object> pushedElements = new ArrayList<Object>();
    // Check if current klass exists
    Validate.notNull(klass, "ERROR: You must specify a valid class to continue with push-in action");
    // Getting class details
    ClassOrInterfaceTypeDetails classDetails = getTypeLocationService().getTypeDetails(klass);
    Validate.notNull(klass, "ERROR: You must specify a valid class to continue with push-in action");
    // String builder where changes will be registered
    StringBuilder changesToApply = new StringBuilder();
    // Getting member details
    MemberDetails memberDetails = getMemberDetailsScanner().getMemberDetails(getClass().getName(), classDetails);
    List<MemberHoldingTypeDetails> memberHoldingTypes = memberDetails.getDetails();
    // Return if the class has not associated ITD's
    if (memberHoldingTypes.size() == 1 && memberHoldingTypes.get(0).getPhysicalTypeCategory() != PhysicalTypeCategory.ITD) {
        return pushedElements;
    }
    // Check if the provided class is a test to be able to select valid
    // class path
    Path path = classDetails.getAnnotation(RooJavaType.ROO_JPA_UNIT_TEST) == null ? Path.SRC_MAIN_JAVA : Path.SRC_TEST_JAVA;
    // Getting current class .java file metadata ID
    final String declaredByMetadataId = PhysicalTypeIdentifier.createIdentifier(klass, getPathResolver().getPath(klass.getModule(), path));
    // Getting detailsBuilder
    ClassOrInterfaceTypeDetailsBuilder detailsBuilder = new ClassOrInterfaceTypeDetailsBuilder(classDetails);
    // Getting all details
    for (final MemberHoldingTypeDetails memberHoldingTypeDetails : memberDetails.getDetails()) {
        // this .java file
        if (!memberHoldingTypeDetails.getType().equals(classDetails.getType())) {
            continue;
        }
        // Getting all declared methods (including declared on ITDs
        // and .java files)
        List<MethodMetadata> allDeclaredMethods = memberHoldingTypeDetails.getMethods();
        // Checking if is necessary to make push-in for all declared methods
        for (MethodMetadata method : allDeclaredMethods) {
            // If method exists on .aj file, add it!
            if (method.getDeclaredByMetadataId().split("\\?").length > 1 && method.getDeclaredByMetadataId().split("\\?")[1].equals(klass.getFullyQualifiedTypeName()) && !method.getDeclaredByMetadataId().equals(declaredByMetadataId)) {
                // Add method to .java file
                MethodMetadata newMethod = getNewMethod(declaredByMetadataId, method);
                detailsBuilder.addMethod(newMethod);
                // Save changes on pushed elements list
                pushedElements.add(newMethod);
                changesToApply.append(String.format("Method '%s' will be pushed on '%s.java' class. \n", method.getMethodName(), klass.getSimpleTypeName()));
            }
        }
        // Getting all declared fields (including declared on ITDs
        // and .java files)
        List<? extends FieldMetadata> allDeclaredFields = memberHoldingTypeDetails.getDeclaredFields();
        // Checking if is necessary to make push-in for all declared fields
        for (FieldMetadata field : allDeclaredFields) {
            // If field exists on .aj file, add it!
            if (field.getDeclaredByMetadataId().split("\\?").length > 1 && field.getDeclaredByMetadataId().split("\\?")[1].equals(klass.getFullyQualifiedTypeName()) && !field.getDeclaredByMetadataId().equals(declaredByMetadataId)) {
                // Add field to .java file
                FieldMetadata newField = getNewField(declaredByMetadataId, field);
                detailsBuilder.addField(newField);
                // Save changes on pushed elements list
                pushedElements.add(newField);
                changesToApply.append(String.format("Field '%s' will be pushed on '%s.java' class. \n", field.getFieldName(), klass.getSimpleTypeName()));
            }
        }
        // Getting all declared constructors (including declared on ITDs and
        // .java files)
        List<? extends ConstructorMetadata> allDeclaredConstructors = memberHoldingTypeDetails.getDeclaredConstructors();
        // constructors
        for (ConstructorMetadata constructor : allDeclaredConstructors) {
            // Check if current constructor exists on .java file
            classDetails = getTypeLocationService().getTypeDetails(detailsBuilder.build().getType());
            List<JavaType> parameterTypes = new ArrayList<JavaType>();
            for (AnnotatedJavaType type : constructor.getParameterTypes()) {
                parameterTypes.add(type.getJavaType());
            }
            ConstructorMetadata javaDeclaredConstructor = classDetails.getDeclaredConstructor(parameterTypes);
            // If not exists, add it!
            if (javaDeclaredConstructor == null) {
                // Add constructor to .java file
                detailsBuilder.addConstructor(constructor);
                // Save changes on pushed elements list
                pushedElements.add(constructor);
                String constructorParametersNames = "";
                for (JavaSymbolName paramName : constructor.getParameterNames()) {
                    constructorParametersNames = constructorParametersNames.concat(paramName.getSymbolName()).concat(", ");
                    changesToApply.append(String.format("Constructor with parameters '%s' will be pushed on '%s.java' class. \n", constructorParametersNames.substring(0, constructorParametersNames.length() - 2), klass.getSimpleTypeName()));
                }
            }
        }
        // Getting all declared annotations (including declared on ITDs
        // and .java files)
        List<AnnotationMetadata> allDeclaredAnnotations = memberHoldingTypeDetails.getAnnotations();
        for (AnnotationMetadata annotation : allDeclaredAnnotations) {
            // Check if current annotation exists on .java file
            classDetails = getTypeLocationService().getTypeDetails(detailsBuilder.build().getType());
            List<AnnotationMetadata> javaDeclaredAnnotations = classDetails.getAnnotations();
            boolean annotationExists = false;
            for (AnnotationMetadata javaAnnotation : javaDeclaredAnnotations) {
                if (javaAnnotation.getAnnotationType().getFullyQualifiedTypeName().equals(annotation.getAnnotationType().getFullyQualifiedTypeName())) {
                    annotationExists = true;
                }
            }
            // If not exists, add it!
            if (!annotationExists) {
                // Add annotation to .java file
                detailsBuilder.addAnnotation(annotation);
                // Save changes on pushed elements list
                pushedElements.add(annotation);
                changesToApply.append(String.format("Annotation '%s' will be pushed on '%s.java' class. \n", annotation.getAnnotationType().getSimpleTypeName(), klass.getSimpleTypeName()));
            }
        }
        // Getting all extends registered on .aj file to move to .java file
        List<JavaType> allExtendsTypes = memberHoldingTypeDetails.getExtendsTypes();
        for (JavaType extendsType : allExtendsTypes) {
            // If extends exists on .aj file, add it!
            if (!detailsBuilder.getExtendsTypes().contains(extendsType)) {
                detailsBuilder.addExtendsTypes(extendsType);
                // Save changes on pushed elements list
                pushedElements.add(extendsType);
                changesToApply.append(String.format("Extends type '%s' will be pushed on '%s.java' class. \n", extendsType.getSimpleTypeName(), klass.getSimpleTypeName()));
            }
        }
        // Getting all implements registered on .aj file to move to .java
        // file
        List<JavaType> allImplementsTypes = memberHoldingTypeDetails.getImplementsTypes();
        for (JavaType implementsType : allImplementsTypes) {
            if (!detailsBuilder.getImplementsTypes().contains(implementsType)) {
                detailsBuilder.addImplementsType(implementsType);
                // Save changes on pushed elements list
                pushedElements.add(implementsType);
                changesToApply.append(String.format("Implements type '%s' will be pushed on '%s.java' class. \n", implementsType.getSimpleTypeName(), klass.getSimpleTypeName()));
            }
        }
        // Getting all imports registered on .aj file to move to .java file
        Set<ImportMetadata> allRegisteredImports = memberHoldingTypeDetails.getImports();
        detailsBuilder.addImports(allRegisteredImports);
        // Save changes on pushed elements list
        pushedElements.add(allRegisteredImports);
    }
    // Updating .java file
    if (!force) {
        // Show message to be able to know which changes will be applied
        if (changesToApply.length() > 0) {
            LOGGER.log(Level.INFO, changesToApply.toString());
        }
    } else if (writeOnDisk) {
        getTypeManagementService().createOrUpdateTypeOnDisk(detailsBuilder.build());
    }
    return pushedElements;
}

Example 2 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class IdentifierMetadata method getParameterizedConstructor.

/**
 * Locates the parameterised constructor consisting of the id fields for
 * this class.
 *
 * @param fields
 * @return the constructor, never null.
 */
private ConstructorMetadataBuilder getParameterizedConstructor(final List<FieldMetadataBuilder> fields) {
    // Search for an existing constructor
    final List<JavaType> parameterTypes = new ArrayList<JavaType>();
    for (final FieldMetadataBuilder field : fields) {
        parameterTypes.add(field.getFieldType());
    }
    final ConstructorMetadata result = governorTypeDetails.getDeclaredConstructor(parameterTypes);
    if (result != null) {
        // Found an existing parameterised constructor on this class
        publicNoArgConstructor = true;
        return null;
    }
    final List<JavaSymbolName> parameterNames = new ArrayList<JavaSymbolName>();
    final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
    bodyBuilder.appendFormalLine("super();");
    for (final FieldMetadataBuilder field : fields) {
        final String fieldName = field.getFieldName().getSymbolName();
        bodyBuilder.appendFormalLine("this." + fieldName + " = " + fieldName + ";");
        parameterNames.add(field.getFieldName());
    }
    // Create the constructor
    final ConstructorMetadataBuilder constructorBuilder = new ConstructorMetadataBuilder(getId());
    constructorBuilder.setModifier(Modifier.PUBLIC);
    constructorBuilder.setParameterTypes(AnnotatedJavaType.convertFromJavaTypes(parameterTypes));
    constructorBuilder.setParameterNames(parameterNames);
    constructorBuilder.setBodyBuilder(bodyBuilder);
    return constructorBuilder;
}

Example 3 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class ControllerOperationsImpl method createJsonDeserializersIfDontExists.

/**
 * Create the Json Desearializer utility class (annotated
 * with @RooDeserializer) for target Entity and its related entities if they
 * aren't created yet.
 *
 * @param entity
 * @param module
 * @param controllerPackage
 */
private void createJsonDeserializersIfDontExists(JavaType currentEntity, String module, JavaPackage controllerPackage) {
    List<JavaType> entitiesToCreateSerializers = getParentAndChildrenRelatedEntities(currentEntity);
    // Check if already exists a serializer for each entity
    Set<ClassOrInterfaceTypeDetails> allDeserializer = getTypeLocationService().findClassesOrInterfaceDetailsWithAnnotation(RooJavaType.ROO_DESERIALIZER);
    for (JavaType entity : entitiesToCreateSerializers) {
        EntityDeserializerAnnotationValues values;
        boolean deserializerFound = false;
        for (ClassOrInterfaceTypeDetails deserializer : allDeserializer) {
            values = new EntityDeserializerAnnotationValues(deserializer);
            if (entity.equals(values.getEntity())) {
                // Found mixing. Nothing to do.
                deserializerFound = true;
            }
        }
        if (!deserializerFound) {
            // Not found deserializer. Create it
            ClassOrInterfaceTypeDetails serviceDetails = getServiceLocator().getService(entity);
            Validate.notNull(serviceDetails, "Can't found service for Entity %s to generate " + "Serializer. If it is a related entity with the one to generate " + "controller, it needs a service.", entity.getFullyQualifiedTypeName());
            // Build @RooDeserializer
            List<AnnotationMetadataBuilder> annotations = new ArrayList<AnnotationMetadataBuilder>();
            annotations = new ArrayList<AnnotationMetadataBuilder>();
            AnnotationMetadataBuilder deserializerAnnotation = new AnnotationMetadataBuilder(RooJavaType.ROO_DESERIALIZER);
            deserializerAnnotation.addClassAttribute("entity", entity);
            annotations.add(deserializerAnnotation);
            JavaType deserializerClass = new JavaType(String.format("%s.%sDeserializer", controllerPackage.getFullyQualifiedPackageName(), entity.getSimpleTypeName()), module);
            final LogicalPath deserializerPath = getPathResolver().getPath(module, Path.SRC_MAIN_JAVA);
            final String resourceIdentifierItem = getTypeLocationService().getPhysicalTypeCanonicalPath(deserializerClass, deserializerPath);
            final String declaredByMetadataIdItem = PhysicalTypeIdentifier.createIdentifier(deserializerClass, getPathResolver().getPath(resourceIdentifierItem));
            ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(declaredByMetadataIdItem, Modifier.PUBLIC, deserializerClass, PhysicalTypeCategory.CLASS);
            cidBuilder.setAnnotations(annotations);
            /*
         * Moved extend to java (instead ITD) because there were
         * compilation problems when Mixin
         * uses @JsonDeserialize(using=EntityDeserializer.class)
         * annotation (requires extend of JsonDeseralizer)
         */
            cidBuilder.addExtendsTypes(JavaType.wrapperOf(JSON_OBJECT_DESERIALIZER, entity));
            FieldMetadata serviceField = EntityDeserializerMetadata.getFieldFor(declaredByMetadataIdItem, serviceDetails.getType());
            FieldMetadata conversionServiceField = EntityDeserializerMetadata.getFieldFor(declaredByMetadataIdItem, SpringJavaType.CONVERSION_SERVICE);
            cidBuilder.addField(serviceField);
            cidBuilder.addField(conversionServiceField);
            ConstructorMetadata constructor = EntityDeserializerMetadata.getConstructor(declaredByMetadataIdItem, serviceField, conversionServiceField);
            cidBuilder.addConstructor(constructor);
            getTypeManagementService().createOrUpdateTypeOnDisk(cidBuilder.build());
        }
    }
}

Example 4 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class ItdSourceFileComposer method writeInnerTypeConstructors.

private void writeInnerTypeConstructors(final JavaType innerType, final List<? extends ConstructorMetadata> constructors, final boolean defineTarget, final boolean isInterfaceMethod) {
    for (final ConstructorMetadata constructor : constructors) {
        Validate.isTrue(constructor.getParameterTypes().size() == constructor.getParameterNames().size(), "One constructor has mismatched parameter names against parameter types");
        // Append annotations
        for (final AnnotationMetadata annotation : constructor.getAnnotations()) {
            appendIndent();
            outputAnnotation(annotation);
            this.newLine(false);
        }
        // Append "<modifier> <methodName>" portion
        appendIndent();
        if (constructor.getModifier() != 0) {
            append(Modifier.toString(constructor.getModifier()));
            append(" ");
        }
        append(innerType.getSimpleTypeName());
        // Append parameter types and names
        append("(");
        final List<AnnotatedJavaType> parameterTypes = constructor.getParameterTypes();
        final List<JavaSymbolName> parameterNames = constructor.getParameterNames();
        for (int i = 0; i < parameterTypes.size(); i++) {
            final AnnotatedJavaType paramType = parameterTypes.get(i);
            final JavaSymbolName paramName = parameterNames.get(i);
            for (final AnnotationMetadata methodParameterAnnotation : paramType.getAnnotations()) {
                outputAnnotation(methodParameterAnnotation);
                append(" ");
            }
            append(paramType.getJavaType().getNameIncludingTypeParameters(false, resolver));
            append(" ");
            append(paramName.getSymbolName());
            if (i < parameterTypes.size() - 1) {
                append(", ");
            }
        }
        // Add exceptions to be thrown
        final List<JavaType> throwsTypes = constructor.getThrowsTypes();
        if (throwsTypes.size() > 0) {
            append(") throws ");
            for (int i = 0; i < throwsTypes.size(); i++) {
                append(throwsTypes.get(i).getNameIncludingTypeParameters(false, resolver));
                if (throwsTypes.size() > i + 1) {
                    append(", ");
                }
            }
        } else {
            append(")");
        }
        if (isInterfaceMethod) {
            append(";");
        } else {
            append(" {");
            this.newLine(false);
            // Add body
            indent();
            append(constructor.getBody());
            indentRemove();
            appendFormalLine("}");
        }
        this.newLine();
    }
}

Example 5 with ConstructorMetadata

use of org.springframework.roo.classpath.details.ConstructorMetadata in project spring-roo by spring-projects.

the class MemberDetailsBuilder method doModification.

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;
        }
    }
}