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()); }
/** * @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(); }
public boolean isPrimitiveElementType(String elementType) { return !OBJECT.equalsIgnoreCase(elementType); }
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); }