private boolean isNumberOrDate(JavaType fieldType) {
   return fieldType.equals(JavaType.DOUBLE_OBJECT)
       || fieldType.equals(JavaType.FLOAT_OBJECT)
       || fieldType.equals(JavaType.INT_OBJECT)
       || fieldType.equals(LONG_OBJECT)
       || fieldType.equals(JavaType.SHORT_OBJECT)
       || fieldType.getFullyQualifiedTypeName().equals(Date.class.getName())
       || fieldType.getFullyQualifiedTypeName().equals(Calendar.class.getName());
 }
 public String getBinder() {
   if (type.equals(JavaType.DOUBLE_OBJECT)) {
     return "g:DoubleBox";
   }
   if (type.equals(LONG_OBJECT)) {
     return "g:LongBox";
   }
   if (type.equals(JavaType.INT_OBJECT)) {
     return "g:IntegerBox";
   }
   if (type.equals(JavaType.FLOAT_OBJECT)) {
     return "r:FloatBox";
   }
   if (type.equals(JavaType.BYTE_OBJECT)) {
     return "r:ByteBox";
   }
   if (type.equals(JavaType.SHORT_OBJECT)) {
     return "r:ShortBox";
   }
   if (type.equals(JavaType.CHAR_OBJECT)) {
     return "r:CharBox";
   }
   if (type.equals(BIG_DECIMAL)) {
     return "r:BigDecimalBox";
   }
   return isCollection()
       ? "a:" + getSetEditor()
       : isDate()
           ? "d:DateBox"
           : isBoolean() ? "g:CheckBox" : isString() ? "g:TextBox" : "g:ValueListBox";
 }
 /**
  * Returns the accessor name for the given field name and field type.
  *
  * @param fieldName the field name used to determine the accessor name
  * @param fieldType the field type
  * @return the accessor method name
  */
 public static JavaSymbolName getAccessorMethodName(
     final JavaSymbolName fieldName, final JavaType fieldType) {
   Validate.notNull(fieldName, "Field name required");
   Validate.notNull(fieldType, "Field type required");
   final String capitalizedFieldName = StringUtils.capitalize(fieldName.getSymbolName());
   return fieldType.equals(JavaType.BOOLEAN_PRIMITIVE)
       ? new JavaSymbolName("is" + capitalizedFieldName)
       : new JavaSymbolName("get" + capitalizedFieldName);
 }
 private JavaType getCollectionImplementation(final JavaType javaType) {
   if (javaType.equals(SET)) {
     return new JavaType(
         HASH_SET.getFullyQualifiedTypeName(),
         javaType.getArray(),
         javaType.getDataType(),
         javaType.getArgName(),
         javaType.getParameters());
   }
   if (javaType.equals(LIST)) {
     return new JavaType(
         ARRAY_LIST.getFullyQualifiedTypeName(),
         javaType.getArray(),
         javaType.getDataType(),
         javaType.getArgName(),
         javaType.getParameters());
   }
   return javaType;
 }
 public boolean isProxy() {
   return ptmd != null
       && !isDate()
       && !isString()
       && !isPrimitive()
       && !isEnum()
       && !isCollection()
       && !isEmbeddable()
       && !type.equals(OBJECT);
 }
 public boolean isPrimitive() {
   return type.isPrimitive()
       || isDate()
       || isString()
       || isBoolean()
       || type.equals(JavaType.DOUBLE_OBJECT)
       || type.equals(LONG_OBJECT)
       || type.equals(JavaType.INT_OBJECT)
       || type.equals(JavaType.FLOAT_OBJECT)
       || type.equals(JavaType.BYTE_OBJECT)
       || type.equals(JavaType.SHORT_OBJECT)
       || type.equals(JavaType.CHAR_OBJECT)
       || type.equals(BIG_DECIMAL);
 }
  public String getFormatter() {
    if (isCollectionOfProxy()) {
      return getCollectionRenderer() + ".render";
    } else if (isDate()) {
      return getDateTimeFormat() + ".format";
    } else if (type.equals(JavaType.INT_OBJECT)
        || type.equals(JavaType.FLOAT_OBJECT)
        || type.equals(JavaType.DOUBLE_OBJECT)
        || type.equals(BIG_INTEGER)
        || type.equals(BIG_DECIMAL)) {
      String formatter = "String.valueOf";
      if (annotations == null || annotations.isEmpty()) {
        return formatter;
      }

      AnnotationMetadata annotation =
          MemberFindingUtils.getAnnotationOfType(annotations, NUMBER_FORMAT);
      if (annotation != null) {
        AnnotationAttributeValue<?> attr = annotation.getAttribute(new JavaSymbolName("style"));
        if (attr != null) {
          String style = attr.getValue().toString();
          if ("org.springframework.format.annotation.NumberFormat.Style.CURRENCY".equals(style)) {
            formatter = "NumberFormat.getCurrencyFormat().format";
          } else if ("org.springframework.format.annotation.NumberFormat.Style.PERCENT"
              .equals(style)) {
            formatter = "NumberFormat.getPercentFormat().format";
          } else {
            formatter = "NumberFormat.getDecimalFormat().format";
          }
        } else {
          formatter = "NumberFormat.getDecimalFormat().format";
        }
      }
      return formatter;
    } else if (isProxy()) {
      return getProxyRendererType() + ".instance().render";
    } else {
      return "String.valueOf";
    }
  }
 public String getRenderer() {
   return isCollection()
       ? getCollectionRenderer()
       : isDate()
           ? "new DateTimeFormatRenderer(" + getDateTimeFormat() + ")"
           : isPrimitive() || isEnum() || isEmbeddable() || type.equals(OBJECT)
               ? "new AbstractRenderer<"
                   + getType()
                   + ">() {\n        public String render("
                   + getType()
                   + " obj) {\n          return obj == null ? \"\" : String.valueOf(obj);\n        }\n      }"
               : getProxyRendererType() + ".instance()";
 }
 private String getEditor() {
   if (type.equals(JavaType.DOUBLE_OBJECT)) {
     return "DoubleBox";
   }
   if (type.equals(LONG_OBJECT)) {
     return "LongBox";
   }
   if (type.equals(JavaType.INT_OBJECT)) {
     return "IntegerBox";
   }
   if (type.equals(JavaType.FLOAT_OBJECT)) {
     return "FloatBox";
   }
   if (type.equals(JavaType.BYTE_OBJECT)) {
     return "ByteBox";
   }
   if (type.equals(JavaType.SHORT_OBJECT)) {
     return "ShortBox";
   }
   if (type.equals(JavaType.CHAR_OBJECT)) {
     return "CharBox";
   }
   if (type.equals(BIG_DECIMAL)) {
     return "BigDecimalBox";
   }
   if (isBoolean()) {
     return "(provided = true) CheckBox";
   }
   return isCollection()
       ? getSetEditor()
       : isDate()
           ? "DateBox"
           : isString()
               ? "TextBox"
               : "(provided = true) ValueListBox<" + type.getFullyQualifiedTypeName() + ">";
 }
  /**
   * Appends the presented class to the end of the presented body declarations. The body
   * declarations appear within the presented compilation unit. This is used to progressively build
   * inner types.
   *
   * @param compilationUnit the work-in-progress compilation unit (required)
   * @param enclosingCompilationUnitServices
   * @param cid the new class to add (required)
   * @param parent the class body declarations a subclass should be added to (may be null, which
   *     denotes a top-level type within the compilation unit)
   */
  private void updateOutput(
      final CompilationUnit compilationUnit,
      CompilationUnitServices enclosingCompilationUnitServices,
      final ClassOrInterfaceTypeDetails cid,
      final List<BodyDeclaration> parent) {
    // Append the new imports this class declares
    Validate.notNull(
        compilationUnit.getImports(),
        "Compilation unit imports should be non-null when producing type '%s'",
        cid.getName());
    for (final ImportMetadata importType : cid.getRegisteredImports()) {
      ImportDeclaration importDeclaration;

      if (!importType.isAsterisk()) {
        NameExpr typeToImportExpr;
        if (importType.getImportType().getEnclosingType() == null) {
          typeToImportExpr =
              new QualifiedNameExpr(
                  new NameExpr(
                      importType.getImportType().getPackage().getFullyQualifiedPackageName()),
                  importType.getImportType().getSimpleTypeName());
        } else {
          typeToImportExpr =
              new QualifiedNameExpr(
                  new NameExpr(
                      importType.getImportType().getEnclosingType().getFullyQualifiedTypeName()),
                  importType.getImportType().getSimpleTypeName());
        }

        importDeclaration = new ImportDeclaration(typeToImportExpr, importType.isStatic(), false);
      } else {
        importDeclaration =
            new ImportDeclaration(
                new NameExpr(importType.getImportPackage().getFullyQualifiedPackageName()),
                importType.isStatic(),
                importType.isAsterisk());
      }

      JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(
          importDeclaration, importType.getCommentStructure());

      compilationUnit.getImports().add(importDeclaration);
    }

    // Create a class or interface declaration to represent this actual type
    final int javaParserModifier = JavaParserUtils.getJavaParserModifier(cid.getModifier());
    TypeDeclaration typeDeclaration;
    ClassOrInterfaceDeclaration classOrInterfaceDeclaration;

    // Implements handling
    final List<ClassOrInterfaceType> implementsList = new ArrayList<ClassOrInterfaceType>();
    for (final JavaType current : cid.getImplementsTypes()) {
      implementsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
    }

    if (cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE
        || cid.getPhysicalTypeCategory() == PhysicalTypeCategory.CLASS) {
      final boolean isInterface = cid.getPhysicalTypeCategory() == PhysicalTypeCategory.INTERFACE;

      if (parent == null) {
        // Top level type
        typeDeclaration =
            new ClassOrInterfaceDeclaration(
                javaParserModifier,
                isInterface,
                cid.getName()
                    .getNameIncludingTypeParameters()
                    .replace(cid.getName().getPackage().getFullyQualifiedPackageName() + ".", ""));
        classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;
      } else {
        // Inner type
        typeDeclaration =
            new ClassOrInterfaceDeclaration(
                javaParserModifier, isInterface, cid.getName().getSimpleTypeName());
        classOrInterfaceDeclaration = (ClassOrInterfaceDeclaration) typeDeclaration;

        if (cid.getName().getParameters().size() > 0) {
          classOrInterfaceDeclaration.setTypeParameters(new ArrayList<TypeParameter>());

          for (final JavaType param : cid.getName().getParameters()) {
            NameExpr pNameExpr =
                JavaParserUtils.importTypeIfRequired(
                    cid.getName(), compilationUnit.getImports(), param);
            final String tempName =
                StringUtils.replace(pNameExpr.toString(), param.getArgName() + " extends ", "", 1);
            pNameExpr = new NameExpr(tempName);
            final ClassOrInterfaceType pResolvedName =
                JavaParserUtils.getClassOrInterfaceType(pNameExpr);
            classOrInterfaceDeclaration
                .getTypeParameters()
                .add(
                    new TypeParameter(
                        param.getArgName().getSymbolName(),
                        Collections.singletonList(pResolvedName)));
          }
        }
      }

      // Superclass handling
      final List<ClassOrInterfaceType> extendsList = new ArrayList<ClassOrInterfaceType>();
      for (final JavaType current : cid.getExtendsTypes()) {
        if (!OBJECT.equals(current)) {
          extendsList.add(JavaParserUtils.getResolvedName(cid.getName(), current, compilationUnit));
        }
      }
      if (extendsList.size() > 0) {
        classOrInterfaceDeclaration.setExtends(extendsList);
      }

      // Implements handling
      if (implementsList.size() > 0) {
        classOrInterfaceDeclaration.setImplements(implementsList);
      }
    } else {
      typeDeclaration = new EnumDeclaration(javaParserModifier, cid.getName().getSimpleTypeName());
    }
    typeDeclaration.setMembers(new ArrayList<BodyDeclaration>());

    Validate.notNull(
        typeDeclaration.getName(), "Missing type declaration name for '%s'", cid.getName());

    // If adding a new top-level type, must add it to the compilation unit
    // types
    Validate.notNull(
        compilationUnit.getTypes(),
        "Compilation unit types must not be null when attempting to add '%s'",
        cid.getName());

    if (parent == null) {
      // Top-level class
      compilationUnit.getTypes().add(typeDeclaration);
    } else {
      // Inner class
      parent.add(typeDeclaration);
    }

    // If the enclosing CompilationUnitServices was not provided a default
    // CompilationUnitServices needs to be created
    if (enclosingCompilationUnitServices == null) {
      // Create a compilation unit so that we can use JavaType*Metadata
      // static methods directly
      enclosingCompilationUnitServices =
          new CompilationUnitServices() {
            @Override
            public JavaPackage getCompilationUnitPackage() {
              return cid.getName().getPackage();
            }

            @Override
            public JavaType getEnclosingTypeName() {
              return cid.getName();
            }

            @Override
            public List<ImportDeclaration> getImports() {
              return compilationUnit.getImports();
            }

            @Override
            public List<TypeDeclaration> getInnerTypes() {
              return compilationUnit.getTypes();
            }

            @Override
            public PhysicalTypeCategory getPhysicalTypeCategory() {
              return cid.getPhysicalTypeCategory();
            }
          };
    }

    final CompilationUnitServices finalCompilationUnitServices = enclosingCompilationUnitServices;
    // A hybrid CompilationUnitServices must be provided that references the
    // enclosing types imports and package
    final CompilationUnitServices compilationUnitServices =
        new CompilationUnitServices() {
          @Override
          public JavaPackage getCompilationUnitPackage() {
            return finalCompilationUnitServices.getCompilationUnitPackage();
          }

          @Override
          public JavaType getEnclosingTypeName() {
            return cid.getName();
          }

          @Override
          public List<ImportDeclaration> getImports() {
            return finalCompilationUnitServices.getImports();
          }

          @Override
          public List<TypeDeclaration> getInnerTypes() {
            return compilationUnit.getTypes();
          }

          @Override
          public PhysicalTypeCategory getPhysicalTypeCategory() {
            return cid.getPhysicalTypeCategory();
          }
        };

    // Add type annotations
    final List<AnnotationExpr> annotations = new ArrayList<AnnotationExpr>();
    typeDeclaration.setAnnotations(annotations);
    for (final AnnotationMetadata candidate : cid.getAnnotations()) {
      JavaParserAnnotationMetadataBuilder.addAnnotationToList(
          compilationUnitServices, annotations, candidate);
    }

    // ROO-3834: Generating default Javadoc inside class if class doesn't contains JavaDoc
    List<Comment> classComments = compilationUnit.getComments();
    if (classComments == null || classComments.isEmpty()) {
      CommentStructure defaultCommentStructure = new CommentStructure();

      String defaultComment =
          "/**\n * = "
              .concat(cid.getType().getSimpleTypeName())
              .concat("\n *\n * TODO Auto-generated class documentation\n *\n */\n");

      defaultCommentStructure.addComment(
          new JavadocComment(defaultComment), CommentLocation.BEGINNING);

      if (annotations.isEmpty()) {
        JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(
            typeDeclaration, defaultCommentStructure);
      } else {
        // If exists some annotation, include comment before the existing annotations
        AnnotationExpr firstAnnotation = annotations.get(0);
        JavaParserCommentMetadataBuilder.updateCommentsToJavaParser(
            firstAnnotation, defaultCommentStructure);
      }
    }

    // Add enum constants and interfaces
    if (typeDeclaration instanceof EnumDeclaration && cid.getEnumConstants().size() > 0) {
      final EnumDeclaration enumDeclaration = (EnumDeclaration) typeDeclaration;

      final List<EnumConstantDeclaration> constants = new ArrayList<EnumConstantDeclaration>();
      enumDeclaration.setEntries(constants);

      for (final JavaSymbolName constant : cid.getEnumConstants()) {
        addEnumConstant(constants, constant);
      }

      // Implements handling
      if (implementsList.size() > 0) {
        enumDeclaration.setImplements(implementsList);
      }
    }

    // Add fields
    for (final FieldMetadata candidate : cid.getDeclaredFields()) {
      JavaParserFieldMetadataBuilder.addField(
          compilationUnitServices, typeDeclaration.getMembers(), candidate);
    }

    // Add constructors
    for (final ConstructorMetadata candidate : cid.getDeclaredConstructors()) {
      JavaParserConstructorMetadataBuilder.addConstructor(
          compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
    }

    // Add methods
    for (final MethodMetadata candidate : cid.getDeclaredMethods()) {
      JavaParserMethodMetadataBuilder.addMethod(
          compilationUnitServices, typeDeclaration.getMembers(), candidate, null);
    }

    // Add inner types
    for (final ClassOrInterfaceTypeDetails candidate : cid.getDeclaredInnerTypes()) {
      updateOutput(
          compilationUnit, compilationUnitServices, candidate, typeDeclaration.getMembers());
    }

    final HashSet<String> imported = new HashSet<String>();
    final ArrayList<ImportDeclaration> imports = new ArrayList<ImportDeclaration>();
    for (final ImportDeclaration importDeclaration : compilationUnit.getImports()) {
      JavaPackage importPackage = null;
      JavaType importType = null;
      if (importDeclaration.isAsterisk()) {
        importPackage = new JavaPackage(importDeclaration.getName().toString());
      } else {
        importType = new JavaType(importDeclaration.getName().toString());
        importPackage = importType.getPackage();
      }

      if (importPackage.equals(cid.getName().getPackage()) && importDeclaration.isAsterisk()) {
        continue;
      }

      if (importPackage.equals(cid.getName().getPackage())
          && importType != null
          && importType.getEnclosingType() == null) {
        continue;
      }

      if (importType != null && importType.equals(cid.getName())) {
        continue;
      }

      if (!imported.contains(importDeclaration.getName().toString())) {
        imports.add(importDeclaration);
        imported.add(importDeclaration.getName().toString());
      }
    }

    Collections.sort(
        imports,
        new Comparator<ImportDeclaration>() {
          @Override
          public int compare(
              final ImportDeclaration importDeclaration,
              final ImportDeclaration importDeclaration1) {
            return importDeclaration
                .getName()
                .toString()
                .compareTo(importDeclaration1.getName().toString());
          }
        });

    compilationUnit.setImports(imports);
  }
Example #11
0
 public boolean isString() {
   return type.equals(JavaType.STRING);
 }
Example #12
0
 public boolean isDate() {
   return type.equals(DATE);
 }
Example #13
0
 public boolean isBoolean() {
   return type.equals(JavaType.BOOLEAN_OBJECT);
 }
Example #14
0
 public boolean isCollection() {
   return type.equals(LIST) || type.equals(SET);
 }