Examples of org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder

Package org.springframework.roo.classpath.details

Examples of org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder

org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder
Builder for {@link ClassOrInterfaceTypeDetails}. @author Ben Alex @since 1.1

    private String updateProxy(final ClassOrInterfaceTypeDetails proxy,
            final List<MethodMetadata> proxyMethods,
            final List<String> exclusionList, final List<String> readOnlyList) {
        // Create a new ClassOrInterfaceTypeDetailsBuilder for the Proxy, will
        // be overridden if the Proxy has already been created
        final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                proxy);


        // Only inherit from EntityProxy if extension is not already defined
        if (!cidBuilder.getExtendsTypes().contains(OLD_ENTITY_PROXY)
                && !cidBuilder.getExtendsTypes().contains(ENTITY_PROXY)) {
            cidBuilder.addExtendsTypes(ENTITY_PROXY);
        }


        if (!cidBuilder.getExtendsTypes().contains(ENTITY_PROXY)) {
            cidBuilder.addExtendsTypes(ENTITY_PROXY);
        }


        final String destinationMetadataId = proxy.getDeclaredByMetadataId();
        final List<MethodMetadataBuilder> methods = new ArrayList<MethodMetadataBuilder>();
        for (final MethodMetadata method : proxyMethods) {
            if (exclusionList.contains(method.getMethodName().getSymbolName())) {
                continue;
            }
            final String propertyName = StringUtils.uncapitalize(BeanInfoUtils
                    .getPropertyNameForJavaBeanMethod(method).getSymbolName());
            if (exclusionList.contains(propertyName)) {
                continue;
            }


            final MethodMetadataBuilder abstractAccessorMethodBuilder = new MethodMetadataBuilder(
                    destinationMetadataId, method);
            abstractAccessorMethodBuilder
                    .setBodyBuilder(new InvocableMemberBodyBuilder());
            abstractAccessorMethodBuilder.setModifier(Modifier.ABSTRACT);
            methods.add(abstractAccessorMethodBuilder);


            if (readOnlyList.contains(propertyName)) {
                continue;
            }
            final MethodMetadataBuilder abstractMutatorMethodBuilder = new MethodMetadataBuilder(
                    destinationMetadataId, method);
            abstractMutatorMethodBuilder
                    .setBodyBuilder(new InvocableMemberBodyBuilder());
            abstractMutatorMethodBuilder.setModifier(Modifier.ABSTRACT);
            abstractMutatorMethodBuilder.setReturnType(JavaType.VOID_PRIMITIVE);
            abstractMutatorMethodBuilder
                    .setParameterTypes(AnnotatedJavaType
                            .convertFromJavaTypes(Arrays.asList(method
                                    .getReturnType())));
            abstractMutatorMethodBuilder.setParameterNames(Arrays
                    .asList(new JavaSymbolName(StringUtils
                            .uncapitalize(propertyName))));
            abstractMutatorMethodBuilder.setMethodName(new JavaSymbolName(
                    method.getMethodName().getSymbolName()
                            .replaceFirst("get", "set")));
            methods.add(abstractMutatorMethodBuilder);
        }


        cidBuilder.setDeclaredMethods(methods);
        return gwtFileManager.write(cidBuilder.build(),
                GwtUtils.PROXY_REQUEST_WARNING);
    }

View Full Code Here

                final String focusedModule = projectOperations
                        .getFocusedModuleName();
                final LogicalPath logicalPath = LogicalPath.getInstance(
                        SRC_MAIN_JAVA, focusedModule);


                ClassOrInterfaceTypeDetailsBuilder builder = new ClassOrInterfaceTypeDetailsBuilder(
                        PhysicalTypeIdentifier.createIdentifier(newClass,
                                logicalPath), legacyView);
                builder.setName(newClass);


                ClassOrInterfaceTypeDetails newView = builder.build();


                gwtFileManager.delete(legacyView);
                gwtFileManager.write(newView, false);


            }

View Full Code Here

        final List<AnnotationAttributeValue<?>> controllerAttributes = new ArrayList<AnnotationAttributeValue<?>>();
        final AnnotationMetadataBuilder controllerAnnotation = new AnnotationMetadataBuilder(
                CONTROLLER, controllerAttributes);
        typeAnnotations.add(controllerAnnotation);


        final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                declaredByMetadataId, Modifier.PUBLIC, controller,
                PhysicalTypeCategory.CLASS);
        cidBuilder.setAnnotations(typeAnnotations);
        cidBuilder.setDeclaredMethods(methods);
        typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());


        installView(
                folderName,
                "/index",
                new JavaSymbolName(controller.getSimpleTypeName())

View Full Code Here

        if (existing == null) {
            LOGGER.warning("Aborting: Unable to find metadata for target type '"
                    + targetType.getFullyQualifiedTypeName() + "'");
            return;
        }
        final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                existing);


        // Add the MailSender field
        final FieldMetadataBuilder mailSenderFieldBuilder = new FieldMetadataBuilder(
                declaredByMetadataId, PRIVATE_TRANSIENT, annotations,
                fieldName, MAIL_SENDER);
        cidBuilder.addField(mailSenderFieldBuilder);


        // Add the "sendMessage" method
        cidBuilder.addMethod(getSendMethod(fieldName, async,
                declaredByMetadataId, cidBuilder));
        typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());
    }

View Full Code Here

            final List<MemberHoldingTypeDetails> extendsTypes,
            final String moduleName) {
        try {
            // A type may consist of a concrete type which depend on
            final List<ClassOrInterfaceTypeDetails> types = new ArrayList<ClassOrInterfaceTypeDetails>();
            final ClassOrInterfaceTypeDetailsBuilder templateClassBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                    templateClass);


            if (destType.isCreateAbstract()) {
                final ClassOrInterfaceTypeDetailsBuilder abstractClassBuilder = createAbstractBuilder(
                        templateClassBuilder, extendsTypes, moduleName);


                final ArrayList<FieldMetadataBuilder> fieldsToRemove = new ArrayList<FieldMetadataBuilder>();
                for (final JavaSymbolName fieldName : destType
                        .getWatchedFieldNames()) {
                    for (final FieldMetadataBuilder fieldBuilder : templateClassBuilder
                            .getDeclaredFields()) {
                        if (fieldBuilder.getFieldName().equals(fieldName)) {
                            final FieldMetadataBuilder abstractFieldBuilder = new FieldMetadataBuilder(
                                    abstractClassBuilder
                                            .getDeclaredByMetadataId(),
                                    fieldBuilder.build());
                            abstractClassBuilder
                                    .addField(convertModifier(abstractFieldBuilder));
                            fieldsToRemove.add(fieldBuilder);
                            break;
                        }
                    }
                }


                templateClassBuilder.getDeclaredFields().removeAll(
                        fieldsToRemove);


                final List<MethodMetadataBuilder> methodsToRemove = new ArrayList<MethodMetadataBuilder>();
                for (final JavaSymbolName methodName : destType
                        .getWatchedMethods().keySet()) {
                    for (final MethodMetadataBuilder methodBuilder : templateClassBuilder
                            .getDeclaredMethods()) {
                        final List<JavaType> params = new ArrayList<JavaType>();
                        for (final AnnotatedJavaType param : methodBuilder
                                .getParameterTypes()) {
                            params.add(new JavaType(param.getJavaType()
                                    .getFullyQualifiedTypeName()));
                        }
                        if (methodBuilder.getMethodName().equals(methodName)) {
                            if (destType.getWatchedMethods().get(methodName)
                                    .containsAll(params)) {
                                final MethodMetadataBuilder abstractMethodBuilder = new MethodMetadataBuilder(
                                        abstractClassBuilder
                                                .getDeclaredByMetadataId(),
                                        methodBuilder.build());
                                abstractClassBuilder
                                        .addMethod(convertModifier(abstractMethodBuilder));
                                methodsToRemove.add(methodBuilder);
                                break;
                            }
                        }
                    }
                }


                templateClassBuilder.removeAll(methodsToRemove);


                for (final JavaType innerTypeName : destType
                        .getWatchedInnerTypes()) {
                    for (final ClassOrInterfaceTypeDetailsBuilder innerTypeBuilder : templateClassBuilder
                            .getDeclaredInnerTypes()) {
                        if (innerTypeBuilder.getName().getSimpleTypeName()
                                .equals(innerTypeName.getSimpleTypeName())) {
                            final ClassOrInterfaceTypeDetailsBuilder builder = new ClassOrInterfaceTypeDetailsBuilder(
                                    abstractClassBuilder
                                            .getDeclaredByMetadataId(),
                                    innerTypeBuilder.build());
                            builder.setName(new JavaType(
                                    innerTypeBuilder.getName()
                                            .getSimpleTypeName() + "_Roo_Gwt",
                                    0, DataType.TYPE, null, innerTypeBuilder
                                            .getName().getParameters()));


                            templateClassBuilder.getDeclaredInnerTypes()
                                    .remove(innerTypeBuilder);
                            if (innerTypeBuilder.getPhysicalTypeCategory()
                                    .equals(PhysicalTypeCategory.INTERFACE)) {
                                final ClassOrInterfaceTypeDetailsBuilder interfaceInnerTypeBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                                        innerTypeBuilder.build());
                                abstractClassBuilder.addInnerType(builder);
                                templateClassBuilder.getDeclaredInnerTypes()
                                        .remove(innerTypeBuilder);
                                interfaceInnerTypeBuilder
                                        .clearDeclaredMethods();
                                interfaceInnerTypeBuilder
                                        .getDeclaredInnerTypes().clear();
                                interfaceInnerTypeBuilder.getExtendsTypes()
                                        .clear();
                                interfaceInnerTypeBuilder
                                        .getExtendsTypes()
                                        .add(new JavaType(
                                                builder.getName()
                                                        .getSimpleTypeName(),
                                                0,

View Full Code Here

                + '.' + abstractName;
        final JavaType abstractType = new JavaType(abstractName);
        final String abstractId = PhysicalTypeIdentifier.createIdentifier(
                abstractType,
                LogicalPath.getInstance(Path.SRC_MAIN_JAVA, moduleName));
        final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                abstractId);
        cidBuilder.setPhysicalTypeCategory(PhysicalTypeCategory.CLASS);
        cidBuilder.setName(abstractType);
        cidBuilder.setModifier(Modifier.ABSTRACT | Modifier.PUBLIC);
        cidBuilder.getExtendsTypes().addAll(concreteClass.getExtendsTypes());
        cidBuilder.add(concreteClass.getRegisteredImports());


        for (final MemberHoldingTypeDetails extendsTypeDetails : extendsTypesDetails) {
            for (final ConstructorMetadata constructor : extendsTypeDetails
                    .getDeclaredConstructors()) {
                final ConstructorMetadataBuilder abstractConstructor = new ConstructorMetadataBuilder(
                        abstractId);
                abstractConstructor.setModifier(constructor.getModifier());


                final Map<JavaSymbolName, JavaType> typeMap = resolveTypes(
                        extendsTypeDetails.getName(), concreteClass
                                .getExtendsTypes().get(0));
                for (final AnnotatedJavaType type : constructor
                        .getParameterTypes()) {
                    JavaType newType = type.getJavaType();
                    if (type.getJavaType().getParameters().size() > 0) {
                        final ArrayList<JavaType> parameterTypes = new ArrayList<JavaType>();
                        for (final JavaType typeType : type.getJavaType()
                                .getParameters()) {
                            final JavaType typeParam = typeMap
                                    .get(new JavaSymbolName(typeType.toString()));
                            if (typeParam != null) {
                                parameterTypes.add(typeParam);
                            }
                        }
                        newType = new JavaType(type.getJavaType()
                                .getFullyQualifiedTypeName(), type
                                .getJavaType().getArray(), type.getJavaType()
                                .getDataType(),
                                type.getJavaType().getArgName(), parameterTypes);
                    }
                    abstractConstructor.getParameterTypes().add(
                            new AnnotatedJavaType(newType));
                }
                abstractConstructor.setParameterNames(constructor
                        .getParameterNames());


                final InvocableMemberBodyBuilder bodyBuilder = new InvocableMemberBodyBuilder();
                bodyBuilder.newLine().indent().append("super(");


                int i = 0;
                for (final JavaSymbolName paramName : abstractConstructor
                        .getParameterNames()) {
                    bodyBuilder.append(" ").append(paramName.getSymbolName());
                    if (abstractConstructor.getParameterTypes().size() > i + 1) {
                        bodyBuilder.append(", ");
                    }
                    i++;
                }


                bodyBuilder.append(");");


                bodyBuilder.newLine().indentRemove();
                abstractConstructor.setBodyBuilder(bodyBuilder);
                cidBuilder.getDeclaredConstructors().add(abstractConstructor);
            }
        }
        return cidBuilder;
    }

View Full Code Here


        // Now let's add the "finders" attribute
        attributes.add(new ArrayAttributeValue<StringAttributeValue>(
                new JavaSymbolName("finders"), desiredFinders));


        final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                cid);
        final AnnotationMetadataBuilder annotation = new AnnotationMetadataBuilder(
                ROO_JPA_ACTIVE_RECORD, attributes);
        cidBuilder.updateTypeAnnotation(annotation.build(),
                new HashSet<JavaSymbolName>());
        typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());
    }

View Full Code Here

                destinationPackage.getFullyQualifiedPackageName() + "."
                        + entity.getName().getSimpleTypeName() + "Proxy");
        final String focusedModule = projectOperations.getFocusedModuleName();
        final LogicalPath proxyLogicalPath = LogicalPath.getInstance(
                SRC_MAIN_JAVA, focusedModule);
        final ClassOrInterfaceTypeDetailsBuilder cidBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                PhysicalTypeIdentifier.createIdentifier(proxyType,
                        proxyLogicalPath));


        cidBuilder.setName(proxyType);
        cidBuilder.setExtendsTypes(Collections.singletonList(ENTITY_PROXY));
        cidBuilder.setPhysicalTypeCategory(INTERFACE);
        cidBuilder.setModifier(PUBLIC);
        final List<AnnotationAttributeValue<?>> attributeValues = new ArrayList<AnnotationAttributeValue<?>>();
        final StringAttributeValue stringAttributeValue = new StringAttributeValue(
                VALUE, entity.getName().getFullyQualifiedTypeName());
        attributeValues.add(stringAttributeValue);
        final String locator = projectOperations
                .getTopLevelPackage(focusedModule)
                + ".server.locator."
                + entity.getName().getSimpleTypeName() + "Locator";
        final StringAttributeValue locatorAttributeValue = new StringAttributeValue(
                new JavaSymbolName("locator"), locator);
        attributeValues.add(locatorAttributeValue);
        cidBuilder.updateTypeAnnotation(new AnnotationMetadataBuilder(
                PROXY_FOR_NAME, attributeValues));
        attributeValues.remove(locatorAttributeValue);
        final List<StringAttributeValue> readOnlyValues = new ArrayList<StringAttributeValue>();
        final FieldMetadata versionField = persistenceMemberLocator
                .getVersionField(entity.getName());
        if (versionField != null) {
            readOnlyValues.add(new StringAttributeValue(VALUE, versionField
                    .getFieldName().getSymbolName()));
        }
        final List<FieldMetadata> idFields = persistenceMemberLocator
                .getIdentifierFields(entity.getName());
        if (!CollectionUtils.isEmpty(idFields)) {
            readOnlyValues.add(new StringAttributeValue(VALUE, idFields.get(0)
                    .getFieldName().getSymbolName()));
        }
        final ArrayAttributeValue<StringAttributeValue> readOnlyAttribute = new ArrayAttributeValue<StringAttributeValue>(
                new JavaSymbolName("readOnly"), readOnlyValues);
        attributeValues.add(readOnlyAttribute);
        cidBuilder.updateTypeAnnotation(new AnnotationMetadataBuilder(
                ROO_GWT_PROXY, attributeValues));
        typeManagementService.createOrUpdateTypeOnDisk(cidBuilder.build());
        addPackageToGwtXml(destinationPackage);
    }

View Full Code Here

                destinationPackage.getFullyQualifiedPackageName() + "."
                        + entity.getType().getSimpleTypeName()
                        + "Request_Roo_Gwt");
        final LogicalPath focusedSrcMainJava = LogicalPath.getInstance(
                SRC_MAIN_JAVA, projectOperations.getFocusedModuleName());
        final ClassOrInterfaceTypeDetailsBuilder requestBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                PhysicalTypeIdentifier.createIdentifier(requestType,
                        focusedSrcMainJava));
        requestBuilder.setName(requestType);
        requestBuilder.addExtendsTypes(REQUEST_CONTEXT);
        requestBuilder.setPhysicalTypeCategory(INTERFACE);
        requestBuilder.setModifier(PUBLIC);
        requestBuilder.addAnnotation(getRooGwtRequestAnnotation(entity));
        typeManagementService.createOrUpdateTypeOnDisk(requestBuilder.build());
        addPackageToGwtXml(destinationPackage);
        // Trigger the GwtRequestMetadataProvider to finish generating the code
        metadataService.get(GwtRequestMetadata.createIdentifier(requestType,
                focusedSrcMainJava));
    }

View Full Code Here

                destinationPackage.getFullyQualifiedPackageName() + "."
                        + entity.getType().getSimpleTypeName() + "Request");


        final LogicalPath focusedSrcMainJava = LogicalPath.getInstance(
                SRC_MAIN_JAVA, projectOperations.getFocusedModuleName());
        final ClassOrInterfaceTypeDetailsBuilder unmanagedRequestBuilder = new ClassOrInterfaceTypeDetailsBuilder(
                PhysicalTypeIdentifier.createIdentifier(unmanagedRequestType,
                        focusedSrcMainJava));
        unmanagedRequestBuilder.setName(unmanagedRequestType);
        unmanagedRequestBuilder.addExtendsTypes(managedRequest.getType());
        unmanagedRequestBuilder.setPhysicalTypeCategory(INTERFACE);
        unmanagedRequestBuilder.setModifier(PUBLIC);
        unmanagedRequestBuilder
                .addAnnotation(getRooGwtUnmanagedRequestAnnotation(entity));
        unmanagedRequestBuilder.addAnnotation(managedRequest
                .getAnnotation(GwtJavaType.SERVICE_NAME));
        typeManagementService.createOrUpdateTypeOnDisk(unmanagedRequestBuilder
                .build());


    }

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.springframework.roo.classpath.details.ClassOrInterfaceTypeDetailsBuilder

org.springframework.roo.addon.dbre.DbreDatabaseListenerImpl

org.springframework.roo.addon.dbre.DbreMetadata

org.springframework.roo.addon.dod.DataOnDemandOperationsImpl

org.springframework.roo.addon.email.MailOperationsImpl

org.springframework.roo.addon.equals.EqualsOperationsImpl

org.springframework.roo.addon.finder.FinderOperationsImpl

org.springframework.roo.addon.gwt.GwtOperationsImpl

org.springframework.roo.addon.gwt.GwtTypeServiceImpl

org.springframework.roo.addon.gwt.locator.GwtLocatorMetadataProviderImpl

org.springframework.roo.addon.gwt.proxy.GwtProxyMetadataProviderImpl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.