示例#1
0
 private String getSetEditor() {
   String typeName = OBJECT.getFullyQualifiedTypeName();
   if (type.getParameters().size() > 0) {
     typeName = type.getParameters().get(0).getSimpleTypeName();
   }
   if (typeName.endsWith(GwtType.PROXY.getSuffix())) {
     typeName = typeName.substring(0, typeName.length() - GwtType.PROXY.getSuffix().length());
   }
   return typeName
       + (type.getSimpleTypeName().equals("Set")
           ? GwtType.SET_EDITOR.getSuffix()
           : GwtType.LIST_EDITOR.getSuffix());
 }
示例#2
0
/**
 * @version $Revision: 1.7 $
 * @author Philippe Le Hégaret
 */
public interface KOMLConstants {

  //    public static final String VERSION = "30, Jun 1998";
  public static final String KOML_DTD = "http://www.inria.fr/koala/XML/koml12.dtd";
  public static final String OLD_VERSION = "24, September 1998";
  public static final int MAJOR_VERSION = 1;
  public static final int MINOR_VERSION = 2;

  public static final String KOML = "koml";
  public static final String OBJECT = "object";
  public static final String OBJECT_CLASS = "object-class";
  public static final String CLASSES = "classes";
  public static final String CLASS = "class";
  public static final String ARRAY = "array";
  public static final String NULL = "null";
  public static final String REFERENCE = "reference";
  public static final String THIS = "this";
  public static final String SUPER = "super";
  public static final String FIELD = "field";
  public static final String ROW = "row";
  public static final String VALUE = "value";

  // attributes names
  public static final String A_VERSION = "version";
  public static final String A_CLASS = "class";
  public static final String A_TYPE = "type";
  public static final String A_NAME = "name";
  public static final String A_UID = "uid";
  public static final String A_ID = "id";
  public static final String A_REF = "ref";
  public static final String A_LENGTH = "length";
  public static final String A_SIZE = "size";
  public static final String A_OBJECT = "object";
  public static final String A_SUPER = "super";
  public static final String A_WRITEMETHOD = "writemethod";
  public static final String A_IMPLEMENTS = "implements";
  public static final String A_TRANSIENT = "transient";

  // values
  public static final String V_BYTE = "byte";
  public static final String V_SHORT = "short";
  public static final String V_INT = "int";
  public static final String V_LONG = "long";
  public static final String V_FLOAT = "float";
  public static final String V_DOUBLE = "double";
  public static final String V_CHAR = "char";
  public static final String V_BOOLEAN = "boolean";
  public static final String V_STRING = "java.lang.String";
  public static final String V_TRUE = "true";
  public static final String V_FALSE = "false";
  public static final String V_SERIALIZABLE = "serializable";
  public static final String V_EXTERNALIZABLE = "externalizable";

  /* HASH CODES */

  public static final int H_KOML = KOML.hashCode();
  public static final int H_OBJECT = OBJECT.hashCode();
  public static final int H_OBJECT_CLASS = OBJECT_CLASS.hashCode();
  public static final int H_CLASSES = CLASSES.hashCode();
  public static final int H_CLASS = CLASS.hashCode();
  public static final int H_ARRAY = ARRAY.hashCode();
  public static final int H_NULL = NULL.hashCode();
  public static final int H_REFERENCE = REFERENCE.hashCode();
  public static final int H_THIS = THIS.hashCode();
  public static final int H_SUPER = SUPER.hashCode();
  public static final int H_FIELD = FIELD.hashCode();
  public static final int H_ROW = ROW.hashCode();
  public static final int H_VALUE = VALUE.hashCode();

  // primitive type
  public static final int H_V_BYTE = V_BYTE.hashCode();
  public static final int H_V_SHORT = V_SHORT.hashCode();
  public static final int H_V_INT = V_INT.hashCode();
  public static final int H_V_LONG = V_LONG.hashCode();
  public static final int H_V_FLOAT = V_FLOAT.hashCode();
  public static final int H_V_DOUBLE = V_DOUBLE.hashCode();
  public static final int H_V_CHAR = V_CHAR.hashCode();
  public static final int H_V_BOOLEAN = V_BOOLEAN.hashCode();
  public static final int H_V_STRING = V_STRING.hashCode();

  public static final int H_V_TRUE = V_TRUE.hashCode();
  public static final int H_V_FALSE = V_FALSE.hashCode();
  public static final int H_V_SERIALIZABLE = V_SERIALIZABLE.hashCode();
  public static final int H_V_EXTERNALIZABLE = V_EXTERNALIZABLE.hashCode();
}
示例#3
0
 public boolean isPrimitiveElementType(String elementType) {
   return !OBJECT.equalsIgnoreCase(elementType);
 }
示例#4
0
 public boolean isObjectColumn() {
   return (OBJECT.equalsIgnoreCase(crateType) && !isMapColumn());
 }
  /**
   * 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);
  }