From 4f104c6b522822ad1bea0ab5799eca0fa6a98d99 Mon Sep 17 00:00:00 2001 From: msunal Date: Mon, 5 Aug 2013 11:09:48 +0200 Subject: [PATCH] Generation of java files from templates - generation of classes, interfaces, enums, builders is doing by using Xtend templates - deleted unnecessary file BuilderClassDescriptor Change-Id: I385604abdb883f2a1ca927b8e7245a692c179744 Signed-off-by: Martin Sunal --- .../api/generator/BuilderClassDescriptor.java | 331 ------ .../java/api/generator/BuilderGenerator.java | 7 +- .../java/api/generator/BuilderTemplate.xtend | 270 ++++- .../api/generator/ClassCodeGenerator.java | 138 --- .../java/api/generator/ClassGenerator.java | 31 + .../java/api/generator/ClassTemplate.xtend | 291 +++++ .../sal/java/api/generator/EnumGenerator.java | 22 +- .../sal/java/api/generator/EnumTemplate.xtend | 43 + .../java/api/generator/GeneratorJavaFile.java | 6 +- .../sal/java/api/generator/GeneratorUtil.java | 1055 +++-------------- .../api/generator/InterfaceGenerator.java | 99 +- .../api/generator/InterfaceTemplate.xtend | 153 +++ .../test/ClassCodeGeneratorTest.java | 8 +- 13 files changed, 884 insertions(+), 1570 deletions(-) delete mode 100644 opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderClassDescriptor.java delete mode 100644 opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassCodeGenerator.java create mode 100644 opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassGenerator.java create mode 100644 opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassTemplate.xtend create mode 100644 opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/EnumTemplate.xtend create mode 100644 opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceTemplate.xtend diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderClassDescriptor.java b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderClassDescriptor.java deleted file mode 100644 index 716afc9b7b..0000000000 --- a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderClassDescriptor.java +++ /dev/null @@ -1,331 +0,0 @@ -package org.opendaylight.controller.sal.java.api.generator; - -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - -import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; -import org.opendaylight.controller.sal.binding.model.api.GeneratedType; -import org.opendaylight.controller.sal.binding.model.api.MethodSignature; -import org.opendaylight.controller.sal.binding.model.api.ParameterizedType; -import org.opendaylight.controller.sal.binding.model.api.Type; -import org.opendaylight.yangtools.yang.binding.Augmentable; - -public class BuilderClassDescriptor { - - private static final String GET_PREFIX = "get"; - private static final String JAVA_UTIL = "java.util"; - private static final String HASH_MAP = "HashMap"; - private static final String MAP = "Map"; - private static final String GET_AUGMENTATION_METHOD_NAME = "getAugmentation"; - - private final GeneratedType genType; - private Map imports; - private final String packageName; - private final String className; - private final Set methods; - private final Set fields; - private final List importsNames; - private FieldDeclaration augmentField; - - class TypeDeclaration { - - private final static String JAVA_LANG_PREFIX = "java.lang"; - private final String name; - private final TypeDeclaration[] generics; - - public TypeDeclaration(String pkg, String name, TypeDeclaration... generics) { - this.name = removeJavaLangPkgName(getRightTypeName(pkg, name)); - if (generics != null && generics.length > 0) { - this.generics = generics; - } else { - this.generics = null; - } - } - - public TypeDeclaration(final Type type) { - if (type == null) { - throw new IllegalArgumentException("Type cannot be NULL"); - } - - this.name = removeJavaLangPkgName(getRightTypeName(type.getPackageName(), type.getName())); - TypeDeclaration[] generics = null; - if (type instanceof ParameterizedType) { - final ParameterizedType pType = (ParameterizedType) type; - final Type[] actualTypeArguments = pType.getActualTypeArguments(); - generics = new TypeDeclaration[actualTypeArguments.length]; - for (int i = 0; i < actualTypeArguments.length; i++) { - generics[i] = new TypeDeclaration(actualTypeArguments[i].getPackageName(), - actualTypeArguments[i].getName()); - } - } - if (generics != null && generics.length > 0) { - this.generics = generics; - } else { - this.generics = null; - } - } - - private String removeJavaLangPkgName(final String typeName) { - if (typeName.startsWith(JAVA_LANG_PREFIX)) { - return typeName.substring(typeName.lastIndexOf(Constants.DOT) + 1); - } - return typeName; - } - - private String getRightTypeName(final String pkg, final String name) { - if (name == null) { - throw new IllegalArgumentException("Name cannot be NULL!"); - } - - if (imports == null) { - return name; - } - final String pkgFromImports = imports.get(name); - if (pkgFromImports == null || pkgFromImports.equals(pkg)) { - return name; - } - return (pkg == null ? "" : pkg) + Constants.DOT + name; - } - - public String getName() { - return name; - } - - public TypeDeclaration[] getGenerics() { - return generics; - } - - } - - class ParameterDeclaration { - - private final TypeDeclaration type; - private final String name; - - public ParameterDeclaration(TypeDeclaration type, String name) { - this.type = type; - this.name = name; - } - - public TypeDeclaration getType() { - return type; - } - - public String getName() { - return name; - } - - } - - class MethodDeclaration { - - private final TypeDeclaration returnType; - private final String name; - private final List parameters; - - public MethodDeclaration(final TypeDeclaration returnType, final String name, - final List parameters) { - this.returnType = returnType; - this.name = name; - if (parameters != null && !parameters.isEmpty()) { - this.parameters = parameters; - } else { - this.parameters = null; - } - } - - public TypeDeclaration getReturnType() { - return returnType; - } - - public String getName() { - return name; - } - - public List getParameters() { - return parameters; - } - - } - - class FieldDeclaration extends ParameterDeclaration { - - public FieldDeclaration(final TypeDeclaration type, final String name) { - super(type, name); - } - - } - - public BuilderClassDescriptor(final GeneratedType genType) { - if (genType == null) { - throw new IllegalArgumentException("Generated type reference cannot be NULL!"); - } - this.genType = genType; - this.imports = GeneratorUtil.createImports(genType); - addToImports(genType.getPackageName(), genType.getName()); - packageName = genType.getPackageName(); - className = genType.getName(); - methods = createMethods(); - fields = createFieldsFromMethods(); - importsNames = createImportsNames(); - } - - private Set createMethods() { - final Set methods = new LinkedHashSet<>(); - storeMethodsOfIfc(methods, genType); - storeMethodsOfImplementedIfcs(methods, genType.getImplements()); - return methods; - } - - private void storeMethodsOfIfc(final Set methodStorage, final GeneratedType ifc) { - for (MethodSignature methodSignature : ifc.getMethodDefinitions()) { - final List parameterDeclarations = getParameterDeclarationsFrom(methodSignature - .getParameters()); - methodStorage.add(new MethodDeclaration(new TypeDeclaration(methodSignature.getReturnType()), - methodSignature.getName(), parameterDeclarations)); - } - if (ifc.getEnclosedTypes() != null && !ifc.getEnclosedTypes().isEmpty()) { - addToImports(ifc.getPackageName(), ifc.getName() + ".*"); - } - } - - private List getParameterDeclarationsFrom(final List parameters) { - final List parameterDeclarations = new ArrayList<>(); - for (MethodSignature.Parameter mp : parameters) { - parameterDeclarations.add(new ParameterDeclaration(new TypeDeclaration(mp.getType()), mp.getName())); - } - return parameterDeclarations; - } - - private void storeMethodsOfImplementedIfcs(final Set methodStorage, - final List implementedIfcs) { - if (implementedIfcs == null || implementedIfcs.isEmpty()) { - return; - } - for (Type implementedIfc : implementedIfcs) { - if ((implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))) { - final GeneratedType ifc = ((GeneratedType) implementedIfc); - storeMethodsOfIfc(methodStorage, ifc); - storeMethodsOfImplementedIfcs(methodStorage, ifc.getImplements()); - } else if (implementedIfc.getFullyQualifiedName().equals(Augmentable.class.getName())) { - for (Method m : Augmentable.class.getMethods()) { - if (m.getName().equals(GET_AUGMENTATION_METHOD_NAME)) { - addToImports(JAVA_UTIL, HASH_MAP); - addToImports(JAVA_UTIL, MAP); - java.lang.reflect.Type returnType = m.getReturnType(); - final String fullyQualifiedName = ((Class) returnType).getName(); - addToImports(getPackageFrom(fullyQualifiedName), getNameFrom(fullyQualifiedName)); - TypeDeclaration augmentMethodType = new TypeDeclaration(getPackageFrom(fullyQualifiedName), - getNameFrom(fullyQualifiedName), new TypeDeclaration(genType)); - augmentField = createFieldFromGetMethod(new MethodDeclaration(augmentMethodType, m.getName(), - null)); - } - } - } - } - } - - private void addToImports(final String pkg, final String name) { - if (imports == null) { - imports = new LinkedHashMap<>(); - } - if (imports.get(name) == null) { - imports.put(name, pkg); - } - } - - private String getPackageFrom(final String fullyQualifiedName) { - final int lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT); - return lastDotIndex == -1 ? "" : fullyQualifiedName.substring(0, lastDotIndex); - } - - private String getNameFrom(final String fullyQualifiedName) { - final int lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT); - return lastDotIndex == -1 ? fullyQualifiedName : fullyQualifiedName.substring(lastDotIndex + 1); - } - - private Set createFieldsFromMethods() { - final Set result = new LinkedHashSet<>(); - - if (methods == null || methods.isEmpty()) { - return result; - } - - for (MethodDeclaration m : methods) { - final FieldDeclaration createdField = createFieldFromGetMethod(m); - if (createdField != null) { - result.add(createdField); - } - } - return result; - } - - private FieldDeclaration createFieldFromGetMethod(final MethodDeclaration method) { - if (method == null || method.getName() == null || method.getName().isEmpty()) { - return null; - } else if (method.getName().startsWith(GET_PREFIX)) { - final String fieldNameFromMethod = method.getName().substring(GET_PREFIX.length()); - final String fieldName = Character.toLowerCase(fieldNameFromMethod.charAt(0)) - + fieldNameFromMethod.substring(1); - return new FieldDeclaration(method.getReturnType(), fieldName); - } - return null; - } - - private List createImportsNames() { - final List result = new ArrayList<>(); - - if (imports == null || imports.isEmpty()) { - return result; - } - - for (Map.Entry entry : imports.entrySet()) { - final String typeName = entry.getKey(); - final String packageName = entry.getValue(); - result.add(packageName + Constants.DOT + typeName); - } - return result; - } - - public String getPackageName() { - return packageName; - } - - /** - * @return list of imports or empty list - */ - public List getImportsNames() { - return importsNames; - } - - public String getClassName() { - return className; - } - - /** - * @return set of methods or empty set - */ - public Set getFields() { - return fields; - } - - /** - * @return set of methods or empty set - */ - public Set getMethods() { - return methods; - } - - /** - * @return declaration of augment field or NULL - */ - public FieldDeclaration getAugmentField() { - return augmentField; - } - -} diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderGenerator.java b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderGenerator.java index 07ee733253..ec99f1edac 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderGenerator.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderGenerator.java @@ -15,10 +15,11 @@ public final class BuilderGenerator implements CodeGenerator { @Override public Writer generate(Type type) throws IOException { - Writer writer = new StringWriter(); + final Writer writer = new StringWriter(); if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { - BuilderTemplate builerGeneratorXtend = new BuilderTemplate(); - writer.write(builerGeneratorXtend.generate(new BuilderClassDescriptor((GeneratedType) type)).toString()); + final GeneratedType genType = (GeneratedType) type; + final BuilderTemplate template = new BuilderTemplate(genType); + writer.write(template.generate().toString()); } return writer; } diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderTemplate.xtend b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderTemplate.xtend index 484fbfb3db..6fe9c1b32d 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderTemplate.xtend +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/BuilderTemplate.xtend @@ -1,96 +1,240 @@ package org.opendaylight.controller.sal.java.api.generator +import java.util.LinkedHashSet import java.util.List +import java.util.Map import java.util.Set +import org.opendaylight.controller.binding.generator.util.ReferencedTypeImpl +import org.opendaylight.controller.binding.generator.util.Types +import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl +import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject +import org.opendaylight.controller.sal.binding.model.api.GeneratedType +import org.opendaylight.controller.sal.binding.model.api.MethodSignature +import org.opendaylight.controller.sal.binding.model.api.Type +import org.opendaylight.yangtools.yang.binding.Augmentable class BuilderTemplate { + val static GET_PREFIX = "get" + val static JAVA_UTIL = "java.util" + val static HASH_MAP = "HashMap" + val static MAP = "Map" + val static GET_AUGMENTATION_METHOD_NAME = "getAugmentation" val static BUILDER = 'Builder' val static IMPL = 'Impl' - - def generate(BuilderClassDescriptor cd) ''' - package «cd.packageName»; - «IF !cd.importsNames.empty» - - «FOR in : cd.importsNames» - import «in»; - «ENDFOR» - «ENDIF» - - public class «cd.className»«BUILDER» { + + val GeneratedType genType + val Map imports + var GeneratedProperty augmentField + val Set fields + + new(GeneratedType genType) { + if (genType == null) { + throw new IllegalArgumentException("Generated type reference cannot be NULL!") + } - «fields(cd.fields, cd.augmentField)» - - «IF !cd.fields.empty» - «FOR field : cd.fields SEPARATOR '\n'» - public «cd.className»«BUILDER» set«field.name.toFirstUpper»(«field.type.name»«field.type.generics.print» «field.name») { - this.«field.name» = «field.name»; - return this; + this.genType = genType + this.imports = GeneratorUtil.createChildImports(genType) + this.fields = createFieldsFromMethods(createMethods) + } + + def private Set createMethods() { + val Set methods = new LinkedHashSet + methods.addAll(genType.methodDefinitions) + storeMethodsOfImplementedIfcs(methods, genType.implements) + return methods + } + + def private void storeMethodsOfImplementedIfcs(Set methods, List implementedIfcs) { + if (implementedIfcs == null || implementedIfcs.empty) { + return + } + for (implementedIfc : implementedIfcs) { + if ((implementedIfc instanceof GeneratedType && !(implementedIfc instanceof GeneratedTransferObject))) { + val ifc = implementedIfc as GeneratedType + methods.addAll(ifc.methodDefinitions) + storeMethodsOfImplementedIfcs(methods, ifc.implements) + } else if (implementedIfc.fullyQualifiedName == Augmentable.name) { + for (m : Augmentable.methods) { + if (m.name == GET_AUGMENTATION_METHOD_NAME) { + addToImports(JAVA_UTIL, HASH_MAP) + addToImports(JAVA_UTIL, MAP) + val fullyQualifiedName = m.returnType.name + val pkg = fullyQualifiedName.package + val name = fullyQualifiedName.name + addToImports(pkg, name) + val tmpGenTO = new GeneratedTOBuilderImpl(pkg, name) + val type = new ReferencedTypeImpl(pkg, name) + val generic = new ReferencedTypeImpl(genType.packageName, genType.name) + val parametrizedReturnType = Types.parameterizedTypeFor(type, generic) + tmpGenTO.addMethod(m.name).setReturnType(parametrizedReturnType) + augmentField = tmpGenTO.toInstance.methodDefinitions.first.createFieldFromGetter } - «ENDFOR» - «ENDIF» - «IF cd.augmentField != null» - - public «cd.className»«BUILDER» add«cd.augmentField.name.toFirstUpper»(Class augmentationType, «cd.augmentField.type.name»«cd.augmentField.type.generics.print» augmentation) { - this.«cd.augmentField.name».put(augmentationType, augmentation); - return this; } - «ENDIF» + } + } + } + + def private void addToImports(String typePackageName,String typeName) { + if (typePackageName.startsWith("java.lang") || typePackageName.isEmpty()) { + return + } + if (!imports.containsKey(typeName)) { + imports.put(typeName, typePackageName) + } + } + + def private first(List elements) { + elements.get(0) + } + + def private String getPackage(String fullyQualifiedName) { + val lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT) + return if (lastDotIndex == -1) "" else fullyQualifiedName.substring(0, lastDotIndex) + } + + def private String getName(String fullyQualifiedName) { + val lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT) + return if (lastDotIndex == -1) fullyQualifiedName else fullyQualifiedName.substring(lastDotIndex + 1) + } + + def private createFieldsFromMethods(Set methods) { + val Set result = new LinkedHashSet + + if (methods == null || methods.isEmpty()) { + return result + } - public «cd.className» build() { - return new «cd.className»«IMPL»(); + for (m : methods) { + val createdField = m.createFieldFromGetter + if (createdField != null) { + result.add(createdField) } + } + return result + } + + def private GeneratedProperty createFieldFromGetter(MethodSignature method) { + if (method == null || method.name == null || method.name.empty || method.returnType == null) { + throw new IllegalArgumentException("Method, method name, method return type reference cannot be NULL or empty!") + } + if (method.name.startsWith(GET_PREFIX)) { + val fieldName = method.getName().substring(GET_PREFIX.length()).toFirstLower + val tmpGenTO = new GeneratedTOBuilderImpl("foo", "foo") + tmpGenTO.addProperty(fieldName).setReturnType(method.returnType) + return tmpGenTO.toInstance.properties.first + } + } + + def generate() { + val body = generateBody + val pkgAndImports = generatePkgAndImports + return pkgAndImports.toString + body.toString + } + + def private generateBody() ''' + public class «genType.name»«BUILDER» { + + «generateFields» - private class «cd.className»«IMPL» implements «cd.className» { + «generateSetters» - «fields(cd.fields, cd.augmentField)» + public «genType.name» build() { + return new «genType.name»«IMPL»(); + } - private «cd.className»«IMPL»() { - «IF !cd.fields.empty» - «FOR field : cd.fields» - this.«field.name» = «cd.className»«BUILDER».this.«field.name»; - «ENDFOR» - «ENDIF» - «IF cd.augmentField != null» - this.«cd.augmentField.name».putAll(«cd.className»«BUILDER».this.«cd.augmentField.name»); - «ENDIF» - } + private class «genType.name»«IMPL» implements «genType.name» { - «IF !cd.fields.empty» - «FOR field : cd.fields SEPARATOR '\n'» - @Override - public «field.type.name»«field.type.generics.print» get«field.name.toFirstUpper»() { - return «field.name»; - } - «ENDFOR» - «ENDIF» - «IF cd.augmentField != null» - - @Override - public E get«cd.augmentField.name.toFirstUpper»(Class augmentationType) { - if (augmentationType == null) { - throw new IllegalArgumentException("Augmentation Type reference cannot be NULL!"); - } - return (E) «cd.augmentField.name».get(augmentationType); - } - «ENDIF» + «generateFields» + + «generateConstructor» + + «generateGetters» } } ''' - def private fields(Set fields, BuilderClassDescriptor.FieldDeclaration augmentField) ''' + def private generateFields() ''' «IF !fields.empty» - «FOR field : fields» - private «field.type.name»«field.type.generics.print» «field.name»; + «FOR f : fields» + private «f.returnType.resolveName» «f.name»; «ENDFOR» «ENDIF» «IF augmentField != null» - private Map, «augmentField.type.name»«augmentField.type.generics.print»> «augmentField.name» = new HashMap<>(); + private Map, «augmentField.returnType.resolveName»> «augmentField.name» = new HashMap<>(); «ENDIF» ''' - def private print(List generics) '''«IF generics != null && !generics.empty»<«FOR generic : generics SEPARATOR ', '»«generic.name»«ENDFOR»>«ENDIF»''' + def private generateSetters() ''' + «FOR field : fields SEPARATOR '\n'» + public «genType.name»«BUILDER» set«field.name.toFirstUpper»(«field.returnType.resolveName» «field.name») { + this.«field.name» = «field.name»; + return this; + } + «ENDFOR» + «IF augmentField != null» + + public «genType.name»«BUILDER» add«augmentField.name.toFirstUpper»(Class augmentationType, «augmentField.returnType.resolveName» augmentation) { + this.«augmentField.name».put(augmentationType, augmentation); + return this; + } + «ENDIF» + ''' + + def private generateConstructor() ''' + private «genType.name»«IMPL»() { + «IF !fields.empty» + «FOR field : fields» + this.«field.name» = «genType.name»«BUILDER».this.«field.name»; + «ENDFOR» + «ENDIF» + «IF augmentField != null» + this.«augmentField.name».putAll(«genType.name»«BUILDER».this.«augmentField.name»); + «ENDIF» + } + ''' + + def private generateGetters() ''' + «IF !fields.empty» + «FOR field : fields SEPARATOR '\n'» + @Override + public «field.returnType.resolveName» get«field.name.toFirstUpper»() { + return «field.name»; + } + «ENDFOR» + «ENDIF» + «IF augmentField != null» + @SuppressWarnings("unchecked") + @Override + public E get«augmentField.name.toFirstUpper»(Class augmentationType) { + if (augmentationType == null) { + throw new IllegalArgumentException("Augmentation Type reference cannot be NULL!"); + } + return (E) «augmentField.name».get(augmentationType); + } + «ENDIF» + ''' + + def private generatePkgAndImports() ''' + package «genType.packageName»; + + + «IF !imports.empty» + «FOR entry : imports.entrySet» + import «entry.value».«entry.key»; + «ENDFOR» + «ENDIF» + + ''' + + def private resolveName(Type type) { + GeneratorUtil.putTypeIntoImports(genType, type, imports); + GeneratorUtil.getExplicitType(genType, type, imports) + } + } + diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassCodeGenerator.java b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassCodeGenerator.java deleted file mode 100644 index 31b94a65ca..0000000000 --- a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassCodeGenerator.java +++ /dev/null @@ -1,138 +0,0 @@ -/* - * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. - * - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0 which accompanies this distribution, - * and is available at http://www.eclipse.org/legal/epl-v10.html - */ -package org.opendaylight.controller.sal.java.api.generator; - -import static org.opendaylight.controller.sal.java.api.generator.Constants.*; - -import java.io.IOException; -import java.io.StringWriter; -import java.io.Writer; -import java.util.List; -import java.util.Map; - -import org.opendaylight.controller.sal.binding.model.api.*; - -public final class ClassCodeGenerator implements CodeGenerator { - - private Map imports; - - private void generatePackage(Writer writer, String packageName) throws IOException { - writer.write(GeneratorUtil.createPackageDeclaration(packageName)); - writer.write(NL); - } - - private void generateImports(Writer writer) throws IOException { - List importLines = GeneratorUtil.createImportLines(imports, null); - for (String line : importLines) { - writer.write(line + NL); - } - writer.write(NL); - } - - private void generateClassBody(Writer writer, GeneratedTransferObject genTO, String packageName, String indent, - boolean isInnerClass) throws IOException { - final List fields = genTO.getProperties(); - final List enums = genTO.getEnumerations(); - final List consts = genTO.getConstantDefinitions(); - - writer.write(GeneratorUtil.createClassDeclaration(genTO, indent, imports, genTO.isAbstract(), isInnerClass)); - writer.write(NL); - writer.write(NL); - - if (consts != null) { - for (Constant con : consts) { - writer.write(GeneratorUtil.createConstant(con, indent + TAB, imports, packageName)); - writer.write(NL); - } - } - - if (enums != null) { - EnumGenerator enumGenerator = new EnumGenerator(); - for (Enumeration e : enums) { - writer.write(enumGenerator.generateInnerEnumeration(e, indent + TAB).toString()); - writer.write(NL); - } - } - - writer.write(GeneratorUtil.createStaticInicializationBlock(genTO, indent + TAB)); - - if (fields != null) { - for (GeneratedProperty field : fields) { - writer.write(GeneratorUtil.createField(field, indent + TAB, imports, packageName) + NL); - } - - writer.write(NL); - final boolean oneConstructor; - if (genTO.isUnionType()) { - oneConstructor = false; - } else { - oneConstructor = true; - } - writer.write(GeneratorUtil.createConstructor(genTO, indent + TAB, imports, genTO.isAbstract(), - oneConstructor)); - writer.write(NL); - - for (GeneratedProperty field : fields) { - writer.write(GeneratorUtil.createGetter(field, indent + TAB, imports, packageName) + NL); - if (!field.isReadOnly()) { - writer.write(GeneratorUtil.createSetter(field, indent + TAB, imports, packageName) + NL); - } - } - - if (!genTO.getHashCodeIdentifiers().isEmpty()) { - writer.write(GeneratorUtil.createHashCode(genTO.getHashCodeIdentifiers(), indent + TAB) + NL); - } - - if (!genTO.getEqualsIdentifiers().isEmpty()) { - writer.write(GeneratorUtil.createEquals(genTO, genTO.getEqualsIdentifiers(), indent + TAB) + NL); - } - - if (!genTO.getToStringIdentifiers().isEmpty()) { - writer.write(GeneratorUtil.createToString(genTO, genTO.getToStringIdentifiers(), indent + TAB) + NL); - } - - writer.write(indent + RCB); - } - } - - @Override - public Writer generate(Type type) throws IOException { - final Writer writer = new StringWriter(); - - if (type instanceof GeneratedTransferObject) { - GeneratedTransferObject genTO = (GeneratedTransferObject) type; - imports = GeneratorUtil.createImports(genTO); - - final String currentPkg = genTO.getPackageName(); - - generatePackage(writer, currentPkg); - - generateImports(writer); - - generateClassBody(writer, genTO, currentPkg, NO_INDENT, false); - - } - return writer; - } - - public Writer generateOnlyClass(Type type, Map imports) throws IOException { - this.imports = imports; - Writer writer = new StringWriter(); - - if (type instanceof GeneratedTransferObject) { - GeneratedTransferObject genTO = (GeneratedTransferObject) type; - - final String currentPkg = ""; - - generateClassBody(writer, genTO, currentPkg, TAB, true); - - } - - return writer; - } -} diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassGenerator.java b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassGenerator.java new file mode 100644 index 0000000000..17940a0daf --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassGenerator.java @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.sal.java.api.generator; + +import java.io.IOException; +import java.io.StringWriter; +import java.io.Writer; + +import org.opendaylight.controller.sal.binding.model.api.CodeGenerator; +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; +import org.opendaylight.controller.sal.binding.model.api.Type; + +public final class ClassGenerator implements CodeGenerator { + + @Override + public Writer generate(Type type) throws IOException { + final Writer writer = new StringWriter(); + if (type instanceof GeneratedTransferObject) { + final GeneratedTransferObject genTO = (GeneratedTransferObject) type; + final ClassTemplate template = new ClassTemplate(genTO); + writer.write(template.generate().toString()); + } + return writer; + } + +} diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassTemplate.xtend b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassTemplate.xtend new file mode 100644 index 0000000000..47a94eb9f4 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/ClassTemplate.xtend @@ -0,0 +1,291 @@ +package org.opendaylight.controller.sal.java.api.generator + +import java.util.List +import java.util.Map +import org.opendaylight.controller.binding.generator.util.TypeConstants +import org.opendaylight.controller.sal.binding.model.api.Constant +import org.opendaylight.controller.sal.binding.model.api.Enumeration +import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject +import org.opendaylight.controller.sal.binding.model.api.Type + +class ClassTemplate { + + val GeneratedTransferObject genTO + val Map imports + val List fields + val List enums + val List consts + + new(GeneratedTransferObject genTO) { + if (genTO == null) { + throw new IllegalArgumentException("Generated transfer object reference cannot be NULL!") + } + + this.genTO = genTO + this.imports = GeneratorUtil.createImports(genTO) + this.fields = genTO.properties + this.enums = genTO.enumerations + this.consts = genTO.constantDefinitions + } + + def generate() { + val body = generateBody(false) + val pkgAndImports = generatePkgAndImports + return pkgAndImports.toString + body.toString + } + + def generateAsInnerClass() { + return generateBody(true) + } + + def private generateBody(boolean isInnerClass) ''' + «genTO.comment.generateComment» + «generateClassDeclaration(isInnerClass)» { + + «generateEnums» + + «generateConstants» + + «generateFields» + + «generateConstructor» + + «FOR field : fields SEPARATOR "\n"» + «field.generateGetter» + «IF !field.readOnly» + + «field.generateSetter» + «ENDIF» + «ENDFOR» + + «generateHashCode» + + «generateEquals» + + «generateToString» + + } + ''' + + def private generateComment(String comment) ''' + «IF comment != null && !comment.empty» + /* + «comment» + */ + «ENDIF» + ''' + + def private generateClassDeclaration(boolean isInnerClass) ''' + public« + IF (isInnerClass)»« + " static final "»« + ELSEIF (genTO.abstract)»« + " abstract "»« + ELSE»« + " "»« + ENDIF»class «genTO.name»« + IF (genTO.extends != null)»« + " extends "»«genTO.extends.resolveName»« + ENDIF»« + IF (!genTO.implements.empty)»« + " implements "»« + FOR type : genTO.implements SEPARATOR ", "»« + type.resolveName»« + ENDFOR»« + ENDIF + »''' + + def private generateEnums() ''' + «IF !enums.empty» + «FOR e : enums SEPARATOR "\n"» + «val enumTemplate = new EnumTemplate(e)» + «enumTemplate.generateAsInnerClass» + «ENDFOR» + «ENDIF» + ''' + + def private generateConstants() ''' + «IF !consts.empty» + «FOR c : consts» + «IF c.name == TypeConstants.PATTERN_CONSTANT_NAME» + «val cValue = c.value» + «IF cValue instanceof List» + «val cValues = cValue as List» + private static final List «Constants.MEMBER_PATTERN_LIST» = new ArrayList(); + public static final List «TypeConstants.PATTERN_CONSTANT_NAME» = Arrays.asList(« + FOR v : cValues SEPARATOR ", "»« + IF v instanceof String»"« + v as String»"« + ENDIF»« + ENDFOR»); + + «generateStaticInicializationBlock» + «ENDIF» + «ELSE» + public static final «c.type.resolveName» «c.name» = «c.value»; + «ENDIF» + «ENDFOR» + «ENDIF» + ''' + + def private generateStaticInicializationBlock() ''' + static { + for (String regEx : «TypeConstants.PATTERN_CONSTANT_NAME») { + «Constants.MEMBER_PATTERN_LIST».add(Pattern.compile(regEx)); + } + } + ''' + def private generateFields() ''' + «IF !fields.empty» + «FOR f : fields» + private «f.returnType.resolveName» «f.name»; + «ENDFOR» + «ENDIF» + ''' + + def private generateConstructor() ''' + «val genTOTopParent = GeneratorUtil.getTopParrentTransportObject(genTO)» + «val properties = GeneratorUtil.resolveReadOnlyPropertiesFromTO(genTO.properties)» + «val propertiesAllParents = GeneratorUtil.getPropertiesOfAllParents(genTO)» + «IF !genTO.unionType» +««« create constructor for every parent property + «IF genTOTopParent != genTO && genTOTopParent.unionType» + «FOR parentProperty : propertiesAllParents SEPARATOR "\n"» + «val parentPropertyAndProperties = properties + #[parentProperty]» + «if (genTO.abstract) "protected" else "public"» «genTO.name»(«parentPropertyAndProperties.generateParameters») { + super(«#[parentProperty].generateParameterNames»); + «FOR property : properties» + this.«property.name» = «property.name»; + «ENDFOR» + } + «ENDFOR» +««« create one constructor + «ELSE» + «val propertiesAll = propertiesAllParents + properties» + «if (genTO.abstract) "protected" else "public"» «genTO.name»(«propertiesAll.generateParameters») { + super(«propertiesAllParents.generateParameterNames()»); + «FOR property : properties» + this.«property.name» = «property.name»; + «ENDFOR» + } + «ENDIF» +««« create constructor for every property + «ELSE» + «FOR property : properties SEPARATOR "\n"» + «val propertyAndTopParentProperties = propertiesAllParents + #[property]» + «if (genTO.abstract) "protected" else "public"» «genTO.name»(«propertyAndTopParentProperties.generateParameters») { + super(«propertiesAllParents.generateParameterNames()»); + this.«property.name» = «property.name»; + } + «ENDFOR» + «ENDIF» + ''' + + def private generateGetter(GeneratedProperty field) ''' + public «field.returnType.resolveName» get«field.name.toFirstUpper»() { + return «field.name»; + } + ''' + + def private generateSetter(GeneratedProperty field) ''' + «val type = field.returnType.resolveName» + public void set«field.name.toFirstUpper»(«type» «field.name») { + this.«field.name» = «field.name»; + } + ''' + + def private generateParameters(Iterable parameters) '''« + IF !parameters.empty»« + FOR parameter : parameters SEPARATOR ", "»« + parameter.returnType.resolveName» «parameter.name»« + ENDFOR»« + ENDIF + »''' + + def private generateParameterNames(Iterable parameters) '''« + IF !parameters.empty»« + FOR parameter : parameters SEPARATOR ", "»« + parameter.name»« + ENDFOR»« + ENDIF + »''' + + def private generateHashCode() ''' + «IF !genTO.hashCodeIdentifiers.empty» + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + «FOR property : genTO.hashCodeIdentifiers» + result = prime * result + ((«property.name» == null) ? 0 : «property.name».hashCode()); + «ENDFOR» + return result; + } + «ENDIF» + ''' + def private generateEquals() ''' + «IF !genTO.equalsIdentifiers.empty» + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + «genTO.name» other = («genTO.name») obj; + «FOR property : genTO.equalsIdentifiers» + «val fieldName = property.name» + if («fieldName» == null) { + if (other.«fieldName» != null) { + return false; + } + } else if(!«fieldName».equals(other.«fieldName»)) { + return false; + } + «ENDFOR» + return true; + } + «ENDIF» + ''' + + def private generateToString() ''' + «IF !genTO.toStringIdentifiers.empty» + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + «val properties = genTO.toStringIdentifiers» + builder.append("«genTO.name» [«properties.get(0).name»="); + builder.append(«properties.get(0).name»); + «FOR i : 1..(); this.enumerations = new HashSet<>(); - this.classGenerator = new ClassCodeGenerator(); + this.classGenerator = new ClassGenerator(); this.enumGenerator = new EnumGenerator(); this.builderGenerator = new BuilderGenerator(); } @@ -42,7 +42,7 @@ public final class GeneratorJavaFile { public GeneratorJavaFile(final Set types, final Set genTransferObjects, final Set enumerations) { this.interfaceGenerator = new InterfaceGenerator(); - this.classGenerator = new ClassCodeGenerator(); + this.classGenerator = new ClassGenerator(); this.enumGenerator = new EnumGenerator(); this.builderGenerator = new BuilderGenerator(); diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/GeneratorUtil.java b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/GeneratorUtil.java index 0e2da81937..34e9abd4b1 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/GeneratorUtil.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/GeneratorUtil.java @@ -7,855 +7,36 @@ */ package org.opendaylight.controller.sal.java.api.generator; -import static org.opendaylight.controller.sal.java.api.generator.Constants.*; +import static org.opendaylight.controller.sal.java.api.generator.Constants.COMMA; import java.util.ArrayList; -import java.util.Iterator; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import org.opendaylight.controller.binding.generator.util.TypeConstants; -import org.opendaylight.controller.sal.binding.model.api.*; import org.opendaylight.controller.binding.generator.util.Types; -import org.opendaylight.controller.sal.binding.model.api.Enumeration.Pair; -import org.opendaylight.controller.sal.binding.model.api.MethodSignature.Parameter; +import org.opendaylight.controller.sal.binding.model.api.Constant; +import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty; +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; +import org.opendaylight.controller.sal.binding.model.api.GeneratedType; +import org.opendaylight.controller.sal.binding.model.api.MethodSignature; +import org.opendaylight.controller.sal.binding.model.api.ParameterizedType; +import org.opendaylight.controller.sal.binding.model.api.Type; +import org.opendaylight.controller.sal.binding.model.api.WildcardType; + public final class GeneratorUtil { private GeneratorUtil() { } - - public static String createIfcDeclaration(final GeneratedType genType, final String indent, - final Map availableImports) { - return createFileDeclaration(IFC, genType, indent, availableImports, false, false); - } - - public static String createClassDeclaration(final GeneratedTransferObject genTransferObject, final String indent, - final Map availableImports, boolean isIdentity, boolean isInnerClass) { - return createFileDeclaration(CLASS, genTransferObject, indent, availableImports, isIdentity, isInnerClass); - } - - public static String createPackageDeclaration(final String packageName) { - return PKG + GAP + packageName + SC; - } - - private static String createFileDeclaration(final String type, final GeneratedType genType, final String indent, - final Map availableImports, boolean isIdentity, boolean innerClass) { - final StringBuilder builder = new StringBuilder(); - final String currentPkg = genType.getPackageName(); - - createComment(builder, genType.getComment(), indent); - - if (!genType.getAnnotations().isEmpty()) { - final List annotations = genType.getAnnotations(); - appendAnnotations(builder, annotations); - builder.append(NL); - } - - if (innerClass) { - builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP + type + GAP + genType.getName() + GAP); - } else if (isIdentity) { - if (!(CLASS.equals(type))) { - throw new IllegalArgumentException("'identity' has to be generated as a class"); - } - builder.append(indent + PUBLIC + GAP + ABSTRACT + GAP + type + GAP + genType.getName() + GAP); - } else { - builder.append(indent + PUBLIC + GAP + type + GAP + genType.getName() + GAP); - } - - if (genType instanceof GeneratedTransferObject) { - GeneratedTransferObject genTO = (GeneratedTransferObject) genType; - - if (genTO.getExtends() != null) { - builder.append(EXTENDS + GAP); - String gtoString = getExplicitType(genTO.getExtends(), availableImports, currentPkg); - builder.append(gtoString + GAP); - } - } - - final List genImplements = genType.getImplements(); - if (!genImplements.isEmpty()) { - if (genType instanceof GeneratedTransferObject) { - builder.append(IMPLEMENTS + GAP); - } else { - builder.append(EXTENDS + GAP); - } - builder.append(getExplicitType(genImplements.get(0), availableImports, currentPkg)); - - for (int i = 1; i < genImplements.size(); ++i) { - builder.append(", "); - builder.append(getExplicitType(genImplements.get(i), availableImports, currentPkg)); - } - } - builder.append(GAP + LCB); - return builder.toString(); - } - - private static StringBuilder appendAnnotations(final StringBuilder builder, final List annotations) { - if ((builder != null) && (annotations != null)) { - for (final AnnotationType annotation : annotations) { - builder.append("@"); - builder.append(annotation.getPackageName()); - builder.append("."); - builder.append(annotation.getName()); - - if (annotation.containsParameters()) { - builder.append("("); - final List parameters = annotation.getParameters(); - appendAnnotationParams(builder, parameters); - builder.append(")"); - } - } - } - return builder; - } - - private static StringBuilder appendAnnotationParams(final StringBuilder builder, - final List parameters) { - if (parameters != null) { - int i = 0; - for (final AnnotationType.Parameter param : parameters) { - if (param == null) { - continue; - } - if (i > 0) { - builder.append(", "); - } - final String paramName = param.getName(); - if (param.getValue() != null) { - builder.append(paramName); - builder.append(" = "); - builder.append(param.getValue()); - } else { - builder.append(paramName); - builder.append(" = {"); - final List values = param.getValues(); - builder.append(values.get(0)); - for (int j = 1; j < values.size(); ++j) { - builder.append(", "); - builder.append(values.get(j)); - } - builder.append("}"); - } - i++; - } - } - return builder; - } - - public static String createConstant(final Constant constant, final String indent, - final Map availableImports, final String currentPkg) { - final StringBuilder builder = new StringBuilder(); - if (constant == null) - throw new IllegalArgumentException(); - builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP); - builder.append(getExplicitType(constant.getType(), availableImports, currentPkg) + GAP + constant.getName()); - builder.append(GAP + "=" + GAP); - - if (constant.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) { - return ""; - } else { - builder.append(constant.getValue()); - } - builder.append(SC); - - return builder.toString(); - } - - public static String createField(final GeneratedProperty property, final String indent, - final Map availableImports, final String currentPkg) { - final StringBuilder builder = new StringBuilder(); - if (!property.getAnnotations().isEmpty()) { - final List annotations = property.getAnnotations(); - appendAnnotations(builder, annotations); - builder.append(NL); - } - builder.append(indent + PRIVATE + GAP); - builder.append(getExplicitType(property.getReturnType(), availableImports, currentPkg) + GAP - + property.getName()); - builder.append(SC); - return builder.toString(); - } - - /** - * Create method declaration in interface. - * - * @param method - * @param indent - * @return - */ - public static String createMethodDeclaration(final MethodSignature method, final String indent, - Map availableImports, final String currentPkg) { - final StringBuilder builder = new StringBuilder(); - - if (method == null) { - throw new IllegalArgumentException("Method Signature parameter MUST be specified and cannot be NULL!"); - } - - final String comment = method.getComment(); - final String name = method.getName(); - if (name == null) { - throw new IllegalStateException("Method Name cannot be NULL!"); - } - - final Type type = method.getReturnType(); - if (type == null) { - throw new IllegalStateException("Method Return type cannot be NULL!"); - } - - final List parameters = method.getParameters(); - - createComment(builder, comment, indent); - builder.append(NL); - - if (!method.getAnnotations().isEmpty()) { - builder.append(indent); - final List annotations = method.getAnnotations(); - appendAnnotations(builder, annotations); - builder.append(NL); - } - - builder.append(indent + getExplicitType(type, availableImports, currentPkg) + GAP + name); - builder.append(LB); - for (int i = 0; i < parameters.size(); i++) { - Parameter p = parameters.get(i); - String separator = COMMA; - if (i + 1 == parameters.size()) { - separator = ""; - } - builder.append(getExplicitType(p.getType(), availableImports, currentPkg) + GAP + p.getName() + separator); - } - builder.append(RB); - builder.append(SC); - - return builder.toString(); - } - - public static String createConstructor(final GeneratedTransferObject genTransferObject, final String indent, - final Map availableImports, final boolean isIdentity, final boolean oneConstructor) { - if (genTransferObject == null) { - throw new IllegalArgumentException("Generated transfer object can't be null"); - } - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (availableImports == null) { - throw new IllegalArgumentException("Map of available imports can't be null"); - } - GeneratedTransferObject genTOTopParent = getTopParrentTransportObject(genTransferObject); - final List ctorProperties = resolveReadOnlyPropertiesFromTO(genTransferObject - .getProperties()); - final List ctorPropertiesAllParents = getPropertiesOfAllParents(genTransferObject - .getExtends()); - - final String currentPkg = genTransferObject.getPackageName(); - final String className = genTransferObject.getName(); - - String constructorPart = ""; - if (oneConstructor) { - if (genTOTopParent != genTransferObject && genTOTopParent.isUnionType()) { - constructorPart = createConstructorForEveryParentProperty(indent, isIdentity, ctorProperties, - ctorPropertiesAllParents, availableImports, currentPkg, className); - - } else { - constructorPart = createOneConstructor(indent, isIdentity, ctorProperties, ctorPropertiesAllParents, - availableImports, currentPkg, className); - } - - } else { // union won't be extended - constructorPart = createConstructorForEveryProperty(indent, isIdentity, ctorProperties, - ctorPropertiesAllParents, availableImports, currentPkg, className); - } - - return constructorPart; - } - - private static String createOneConstructor(final String indent, boolean isIdentity, - final List properties, final List propertiesAllParents, - final Map availableImports, final String currentPkg, final String className) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (properties == null) { - throw new IllegalArgumentException("List of generated properties can't be null"); - } - if (propertiesAllParents == null) { - throw new IllegalArgumentException( - "List of generated properties of all parent transport objects can't be null"); - } - if (availableImports == null) { - throw new IllegalArgumentException("Map of available imports can't be null"); - } - if (currentPkg == null) { - throw new IllegalArgumentException("String with current package can't be null"); - } - if (className == null) { - throw new IllegalArgumentException("String with class name can't be null"); - } - - final StringBuilder builder = new StringBuilder(); - - List propertiesAll = new ArrayList(properties); - propertiesAll.addAll(propertiesAllParents); - - builder.append(createConstructorDeclarationToLeftParenthesis(className, indent, isIdentity)); - builder.append(createMethodPropertiesDeclaration(propertiesAll, availableImports, currentPkg, COMMA + GAP)); - builder.append(createConstructorDeclarationFromRightParenthesis()); - builder.append(createConstructorSuper(propertiesAllParents, indent)); - builder.append(createClassPropertiesInitialization(propertiesAll, indent)); - builder.append(createConstructorClosingPart(indent)); - return builder.toString(); - } - - private static String createConstructorForEveryParentProperty(final String indent, final boolean isIdentity, - final List properties, final List propertiesAllParents, - final Map availableImports, final String currentPkg, final String className) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (properties == null) { - throw new IllegalArgumentException("List of generated properties can't be null"); - } - if (propertiesAllParents == null) { - throw new IllegalArgumentException( - "List of generated properties of all parent transport objects can't be null"); - } - if (availableImports == null) { - throw new IllegalArgumentException("Map of available imports can't be null"); - } - if (currentPkg == null) { - throw new IllegalArgumentException("String with current package can't be null"); - } - if (className == null) { - throw new IllegalArgumentException("String with class name can't be null"); - } - final StringBuilder builder = new StringBuilder(); - GeneratedProperty parentProperty; - Iterator parentPropertyIterator = propertiesAllParents.iterator(); - - do { - parentProperty = null; - if (parentPropertyIterator.hasNext()) { - parentProperty = parentPropertyIterator.next(); - } - - List propertiesAndParentProperties = new ArrayList(); - if (parentProperty != null) { - propertiesAndParentProperties.add(parentProperty); - } - propertiesAndParentProperties.addAll(properties); - - builder.append(createConstructorDeclarationToLeftParenthesis(className, indent, isIdentity)); - builder.append(createMethodPropertiesDeclaration(propertiesAndParentProperties, availableImports, - currentPkg, COMMA + GAP)); - builder.append(createConstructorDeclarationFromRightParenthesis()); - builder.append(createConstructorSuper(parentProperty, indent)); - builder.append(createClassPropertiesInitialization(properties, indent)); - builder.append(createConstructorClosingPart(indent)); - } while (parentPropertyIterator.hasNext()); - - return builder.toString(); - } - - private static String createConstructorForEveryProperty(final String indent, final boolean isIdentity, - final List properties, final List propertiesAllParents, - final Map availableImports, final String currentPkg, final String className) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (properties == null) { - throw new IllegalArgumentException("List of generated properties can't be null"); - } - if (propertiesAllParents == null) { - throw new IllegalArgumentException( - "List of generated properties of all parent transport objects can't be null"); - } - if (availableImports == null) { - throw new IllegalArgumentException("Map of available imports can't be null"); - } - if (currentPkg == null) { - throw new IllegalArgumentException("String with current package can't be null"); - } - if (className == null) { - throw new IllegalArgumentException("String with class name can't be null"); - } - - final StringBuilder builder = new StringBuilder(); - - GeneratedProperty property; - Iterator propertyIterator = properties.iterator(); - - do { - property = null; - if (propertyIterator.hasNext()) { - property = propertyIterator.next(); - } - - List propertyAndTopParentProperties = new ArrayList(); - if (property != null) { - propertyAndTopParentProperties.add(property); - } - propertyAndTopParentProperties.addAll(propertiesAllParents); - - builder.append(createConstructorDeclarationToLeftParenthesis(className, indent, isIdentity)); - builder.append(createMethodPropertiesDeclaration(propertyAndTopParentProperties, availableImports, - currentPkg, COMMA + GAP)); - builder.append(createConstructorDeclarationFromRightParenthesis()); - builder.append(createConstructorSuper(propertiesAllParents, indent)); - builder.append(createClassPropertyInitialization(property, indent)); - builder.append(createConstructorClosingPart(indent)); - } while (propertyIterator.hasNext()); - - return builder.toString(); - } - - /** - * The method selects from input list of properties only those which have - * read only attribute set to true. - * - * @param properties - * contains list of properties of generated transfer object - * @return subset of properties which have read only attribute - * set to true - */ - private static List resolveReadOnlyPropertiesFromTO(List properties) { - List readOnlyProperties = new ArrayList(); - if (properties != null) { - for (final GeneratedProperty property : properties) { - if (property.isReadOnly()) { - readOnlyProperties.add(property); - } - } - } - return readOnlyProperties; - } - - private static String createMethodPropertiesDeclaration(final List parameters, - final Map availableImports, final String currentPkg, final String parameterSeparator) { - StringBuilder builder = new StringBuilder(); - if (parameters == null) { - throw new IllegalArgumentException("List of generated properties can't be null"); - } - if (availableImports == null) { - throw new IllegalArgumentException("Map of available imports can't be null"); - } - if (currentPkg == null) { - throw new IllegalArgumentException("String with current package can't be null"); - } - if (parameterSeparator == null) { - throw new IllegalArgumentException("String with separator of parameters can't be null"); - } - - for (final GeneratedProperty parameter : parameters) { - builder.append(createMethodPropertyDeclaration(parameter, availableImports, currentPkg)); - builder.append(parameterSeparator); - } - if (!parameters.isEmpty()) { - builder = builder.delete(builder.length() - parameterSeparator.length(), builder.length()); - } - return builder.toString(); - } - - private static String createConstructorDeclarationToLeftParenthesis(final String className, final String indent, - final boolean isIdentity) { - if (className == null) { - throw new IllegalArgumentException("String with class name can't be null"); - } - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - final StringBuilder builder = new StringBuilder(); - builder.append(indent); - builder.append(isIdentity ? PROTECTED : PUBLIC); - builder.append(GAP); - builder.append(className); - builder.append(LB); - return builder.toString(); - } - - private static String createConstructorDeclarationFromRightParenthesis() { - final StringBuilder builder = new StringBuilder(); - builder.append(RB + GAP + LCB + NL); - return builder.toString(); - } - - private static String createConstructorSuper(final List propertiesAllParents, final String indent) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (propertiesAllParents == null) { - throw new IllegalArgumentException("List of all parent's properties can't be null"); - } - StringBuilder builder = new StringBuilder(); - builder.append(indent + TAB + "super("); - String propertySeparator = COMMA + GAP; - for (GeneratedProperty superProperty : propertiesAllParents) { - builder.append(superProperty.getName()); - builder.append(propertySeparator); - } - if (!propertiesAllParents.isEmpty()) { - builder = builder.delete(builder.length() - propertySeparator.length(), builder.length()); - } - - builder.append(");" + NL); - return builder.toString(); - } - - private static String createConstructorSuper(final GeneratedProperty parentProperty, final String indent) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (parentProperty == null) { - throw new IllegalArgumentException("Parent property can't be null"); - } - StringBuilder builder = new StringBuilder(); - if (parentProperty != null) { - builder.append(indent + TAB + "super("); - builder.append(parentProperty.getName()); - builder.append(");" + NL); - } - return builder.toString(); - } - - private static String createConstructorClosingPart(final String indent) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - final StringBuilder builder = new StringBuilder(); - builder.append(indent); - builder.append(RCB); - builder.append(NL + NL); - return builder.toString(); - } - - private static String createClassPropertiesInitialization(final List properties, - final String indent) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (properties == null) { - throw new IllegalArgumentException("List of generated class properties can't be null"); - } - final StringBuilder builder = new StringBuilder(); - for (final GeneratedProperty property : properties) { - createClassPropertyInitialization(property, indent); - } - return builder.toString(); - } - - private static String createClassPropertyInitialization(final GeneratedProperty property, final String indent) { - if (indent == null) { - throw new IllegalArgumentException("String with indent can't be null"); - } - if (property == null) { - throw new IllegalArgumentException("List of generated class properties can't be null"); - } - final StringBuilder builder = new StringBuilder(); - builder.append(indent); - builder.append(TAB); - builder.append("this."); - builder.append(property.getName()); - builder.append(" = "); - builder.append(property.getName()); - builder.append(SC); - builder.append(NL); - return builder.toString(); - } - - private static String createMethodPropertyDeclaration(final GeneratedProperty property, - final Map availableImports, final String currentPkg) { - if (property == null) { - throw new IllegalArgumentException("Generated property can't be null"); - } - if (availableImports == null) { - throw new IllegalArgumentException("Map of available imports can't be null"); - } - if (currentPkg == null) { - throw new IllegalArgumentException("String with current package can't be null"); - } - final StringBuilder builder = new StringBuilder(); - builder.append(getExplicitType(property.getReturnType(), availableImports, currentPkg)); - builder.append(GAP); - builder.append(property.getName()); - return builder.toString(); - } - - public static String createGetter(final GeneratedProperty property, final String indent, - final Map availableImports, final String currentPkg) { - final StringBuilder builder = new StringBuilder(); - - final Type type = property.getReturnType(); - final String varName = property.getName(); - final char first = Character.toUpperCase(varName.charAt(0)); - final String methodName = "get" + first + varName.substring(1); - - builder.append(indent + PUBLIC + GAP + getExplicitType(type, availableImports, currentPkg) + GAP + methodName); - builder.append(LB + RB + LCB + NL); - - String currentIndent = indent + TAB; - - builder.append(currentIndent + "return " + varName + SC + NL); - - builder.append(indent + RCB); - return builder.toString(); - } - - public static String createSetter(final GeneratedProperty property, final String indent, - final Map availableImports, final String currentPkg) { - final StringBuilder builder = new StringBuilder(); - - final Type type = property.getReturnType(); - final String varName = property.getName(); - final char first = Character.toUpperCase(varName.charAt(0)); - final String methodName = "set" + first + varName.substring(1); - - builder.append(indent + PUBLIC + GAP + "void" + GAP + methodName); - builder.append(LB + getExplicitType(type, availableImports, currentPkg) + GAP + varName + RB + LCB + NL); - String currentIndent = indent + TAB; - builder.append(currentIndent + "this." + varName + " = " + varName + SC + NL); - builder.append(indent + RCB); - return builder.toString(); - } - - public static String createHashCode(final List properties, final String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(indent + "public int hashCode() {" + NL); - builder.append(indent + TAB + "final int prime = 31;" + NL); - builder.append(indent + TAB + "int result = 1;" + NL); - - for (GeneratedProperty property : properties) { - String fieldName = property.getName(); - builder.append(indent + TAB + "result = prime * result + ((" + fieldName + " == null) ? 0 : " + fieldName - + ".hashCode());" + NL); - } - - builder.append(indent + TAB + "return result;" + NL); - builder.append(indent + RCB + NL); - return builder.toString(); - } - - public static String createEquals(final GeneratedTransferObject type, final List properties, - final String indent) { - final StringBuilder builder = new StringBuilder(); - final String indent1 = indent + TAB; - final String indent2 = indent1 + TAB; - final String indent3 = indent2 + TAB; - - builder.append(indent + "public boolean equals(Object obj) {" + NL); - builder.append(indent1 + "if (this == obj) {" + NL); - builder.append(indent2 + "return true;" + NL); - builder.append(indent1 + "}" + NL); - builder.append(indent1 + "if (obj == null) {" + NL); - builder.append(indent2 + "return false;" + NL); - builder.append(indent1 + "}" + NL); - builder.append(indent1 + "if (getClass() != obj.getClass()) {" + NL); - builder.append(indent2 + "return false;" + NL); - builder.append(indent1 + "}" + NL); - - String typeStr = type.getName(); - builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;" + NL); - - for (final GeneratedProperty property : properties) { - String fieldName = property.getName(); - builder.append(indent1 + "if (" + fieldName + " == null) {" + NL); - builder.append(indent2 + "if (other." + fieldName + " != null) {" + NL); - builder.append(indent3 + "return false;" + NL); - builder.append(indent2 + "}" + NL); - builder.append(indent1 + "} else if (!" + fieldName + ".equals(other." + fieldName + ")) {" + NL); - builder.append(indent2 + "return false;" + NL); - builder.append(indent1 + "}" + NL); - } - - builder.append(indent1 + "return true;" + NL); - builder.append(indent + RCB + NL); - return builder.toString(); - } - - public static String createToString(final GeneratedTransferObject type, final List properties, - final String indent) { - StringBuilder builder = new StringBuilder(); - builder.append(indent); - builder.append("public String toString() {"); - builder.append(NL); - builder.append(indent); - builder.append(TAB); - builder.append("StringBuilder builder = new StringBuilder();"); - builder.append(NL); - builder.append(indent); - builder.append(TAB); - builder.append("builder.append(\""); - builder.append(type.getName()); - builder.append(" ["); - - boolean first = true; - for (final GeneratedProperty property : properties) { - if (first) { - builder.append(property.getName()); - builder.append("=\");"); - builder.append(NL); - builder.append(indent); - builder.append(TAB); - builder.append("builder.append("); - builder.append(property.getName()); - builder.append(");"); - first = false; - } else { - builder.append(NL); - builder.append(indent); - builder.append(TAB); - builder.append("builder.append(\", "); - builder.append(property.getName()); - builder.append("=\");"); - builder.append(NL); - builder.append(indent); - builder.append(TAB); - builder.append("builder.append("); - builder.append(property.getName()); - builder.append(");"); - } - } - builder.append(NL); - builder.append(indent); - builder.append(TAB); - builder.append("builder.append(\"]\");"); - builder.append(NL); - builder.append(indent); - builder.append(TAB); - builder.append("return builder.toString();"); - - builder.append(NL); - builder.append(indent); - builder.append(RCB); - builder.append(NL); - return builder.toString(); - } - - public static String createEnum(final Enumeration enumeration, final String indent) { - if (enumeration == null || indent == null) - throw new IllegalArgumentException(); - final StringBuilder builder = new StringBuilder(indent + PUBLIC + GAP + ENUM + GAP + enumeration.getName() - + GAP + LCB + NL); - - String separator = COMMA + NL; - final List values = enumeration.getValues(); - - for (int i = 0; i < values.size(); i++) { - if (i + 1 == values.size()) { - separator = SC; - } - builder.append(indent + TAB + values.get(i).getName() + LB + values.get(i).getValue() + RB + separator); - } - builder.append(NL); - builder.append(NL); - final String ENUMERATION_NAME = "value"; - final String ENUMERATION_TYPE = "int"; - builder.append(indent + TAB + ENUMERATION_TYPE + GAP + ENUMERATION_NAME + SC); - builder.append(NL); - builder.append(indent + TAB + PRIVATE + GAP + enumeration.getName() + LB + ENUMERATION_TYPE + GAP - + ENUMERATION_NAME + RB + GAP + LCB + NL); - builder.append(indent + TAB + TAB + "this." + ENUMERATION_NAME + GAP + "=" + GAP + ENUMERATION_NAME + SC + NL); - builder.append(indent + TAB + RCB + NL); - - builder.append(indent + RCB); - builder.append(NL); - return builder.toString(); - } - - private static String getExplicitType(final Type type, final Map imports, final String currentPkg) { - if (type == null) { - throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!"); - } - if (type.getName() == null) { - throw new IllegalArgumentException("Type name cannot be NULL!"); - } - if (type.getPackageName() == null) { - throw new IllegalArgumentException("Type cannot have Package Name referenced as NULL!"); - } - if (imports == null) { - throw new IllegalArgumentException("Imports Map cannot be NULL!"); - } - - final String typePackageName = type.getPackageName(); - final String typeName = type.getName(); - final String importedPackageName = imports.get(typeName); - if (typePackageName.equals(importedPackageName) || typePackageName.equals(currentPkg)) { - final StringBuilder builder = new StringBuilder(type.getName()); - if (type instanceof ParameterizedType) { - final ParameterizedType pType = (ParameterizedType) type; - final Type[] pTypes = pType.getActualTypeArguments(); - builder.append("<"); - builder.append(getParameters(pTypes, imports, currentPkg)); - builder.append(">"); - } - if (builder.toString().equals("Void")) { - return "void"; - } - return builder.toString(); - } else { - final StringBuilder builder = new StringBuilder(); - if (typePackageName.startsWith("java.lang")) { - builder.append(type.getName()); - } else { - if (!typePackageName.isEmpty()) { - builder.append(typePackageName + "." + type.getName()); - } else { - builder.append(type.getName()); - } - } - if (type.equals(Types.voidType())) { - return "void"; - } - if (type instanceof ParameterizedType) { - final ParameterizedType pType = (ParameterizedType) type; - final Type[] pTypes = pType.getActualTypeArguments(); - builder.append("<"); - builder.append(getParameters(pTypes, imports, currentPkg)); - builder.append(">"); - } - return builder.toString(); - } - } - - private static String getParameters(final Type[] pTypes, Map availableImports, String currentPkg) { - final StringBuilder builder = new StringBuilder(); - for (int i = 0; i < pTypes.length; i++) { - final Type t = pTypes[i]; - - String separator = COMMA; - if (i == (pTypes.length - 1)) { - separator = ""; - } - - String wildcardParam = ""; - if (t.equals(Types.voidType())) { - builder.append("java.lang.Void" + separator); - continue; - } else { - - if (t instanceof WildcardType) { - wildcardParam = "? extends "; - } - - builder.append(wildcardParam + getExplicitType(t, availableImports, currentPkg) + separator); - } - } - return builder.toString(); - } - - private static void createComment(final StringBuilder builder, final String comment, final String indent) { - if (comment != null && comment.length() > 0) { - builder.append(indent + "/*" + NL); - builder.append(indent + comment + NL); - builder.append(indent + "*/" + NL); - } - } - + public static Map createImports(GeneratedType genType) { if (genType == null) { throw new IllegalArgumentException("Generated Type cannot be NULL!"); } final Map imports = new LinkedHashMap<>(); + imports.put(genType.getName(), genType.getPackageName()); List childGeneratedTypes = genType.getEnclosedTypes(); if (!childGeneratedTypes.isEmpty()) { for (GeneratedType genTypeChild : childGeneratedTypes) { @@ -916,20 +97,8 @@ public final class GeneratorUtil { return imports; } - - public static Map createChildImports(GeneratedType genType) { - Map childImports = new LinkedHashMap<>(); - List childGeneratedTypes = genType.getEnclosedTypes(); - if (!childGeneratedTypes.isEmpty()) { - for (GeneratedType genTypeChild : childGeneratedTypes) { - createChildImports(genTypeChild); - childImports.put(genTypeChild.getName(), genTypeChild.getPackageName()); - } - } - return childImports; - } - - private static void putTypeIntoImports(final GeneratedType parentGenType, final Type type, + + public static void putTypeIntoImports(final GeneratedType parentGenType, final Type type, final Map imports) { if (parentGenType == null) { throw new IllegalArgumentException("Parent Generated Type parameter MUST be specified and cannot be " @@ -970,26 +139,7 @@ public final class GeneratorUtil { } } } - - public static List createImportLines(final Map imports, - final Map innerTypeImports) { - final List importLines = new ArrayList<>(); - - for (Map.Entry entry : imports.entrySet()) { - final String typeName = entry.getKey(); - final String packageName = entry.getValue(); - if (innerTypeImports != null) { - String innerTypePackageName = innerTypeImports.get(typeName); - if (innerTypePackageName != null) { - if (innerTypePackageName.equals(packageName)) - continue; - } - } - importLines.add("import " + packageName + "." + typeName + SC); - } - return importLines; - } - + public static boolean isConstantInTO(String constName, GeneratedTransferObject genTO) { if (constName == null || genTO == null) throw new IllegalArgumentException(); @@ -1002,7 +152,100 @@ public final class GeneratorUtil { } return false; } + + public static Map createChildImports(GeneratedType genType) { + Map childImports = new LinkedHashMap<>(); + List childGeneratedTypes = genType.getEnclosedTypes(); + if (!childGeneratedTypes.isEmpty()) { + for (GeneratedType genTypeChild : childGeneratedTypes) { + createChildImports(genTypeChild); + childImports.put(genTypeChild.getName(), genTypeChild.getPackageName()); + } + } + return childImports; + } + + public static String getExplicitType(final GeneratedType parentGenType, final Type type, final Map imports) { + if (type == null) { + throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!"); + } + if (type.getName() == null) { + throw new IllegalArgumentException("Type name cannot be NULL!"); + } + if (type.getPackageName() == null) { + throw new IllegalArgumentException("Type cannot have Package Name referenced as NULL!"); + } + if (imports == null) { + throw new IllegalArgumentException("Imports Map cannot be NULL!"); + } + + final String typePackageName = type.getPackageName(); + final String typeName = type.getName(); + final String importedPackageName = imports.get(typeName); + if (typePackageName.equals(importedPackageName) || typePackageName.equals(parentGenType.getPackageName())) { + final StringBuilder builder = new StringBuilder(type.getName()); + if (type instanceof ParameterizedType) { + final ParameterizedType pType = (ParameterizedType) type; + final Type[] pTypes = pType.getActualTypeArguments(); + builder.append("<"); + builder.append(getParameters(parentGenType, pTypes, imports)); + builder.append(">"); + } + if (builder.toString().equals("Void")) { + return "void"; + } + return builder.toString(); + } else { + final StringBuilder builder = new StringBuilder(); + if (typePackageName.startsWith("java.lang")) { + builder.append(type.getName()); + } else { + if (!typePackageName.isEmpty()) { + builder.append(typePackageName + Constants.DOT + type.getName()); + } else { + builder.append(type.getName()); + } + } + if (type.equals(Types.voidType())) { + return "void"; + } + if (type instanceof ParameterizedType) { + final ParameterizedType pType = (ParameterizedType) type; + final Type[] pTypes = pType.getActualTypeArguments(); + builder.append("<"); + builder.append(getParameters(parentGenType, pTypes, imports)); + builder.append(">"); + } + return builder.toString(); + } + } + + private static String getParameters(final GeneratedType parentGenType, final Type[] pTypes, Map availableImports) { + final StringBuilder builder = new StringBuilder(); + for (int i = 0; i < pTypes.length; i++) { + final Type t = pTypes[i]; + + String separator = COMMA; + if (i == (pTypes.length - 1)) { + separator = ""; + } + + String wildcardParam = ""; + if (t.equals(Types.voidType())) { + builder.append("java.lang.Void" + separator); + continue; + } else { + + if (t instanceof WildcardType) { + wildcardParam = "? extends "; + } + builder.append(wildcardParam + getExplicitType(parentGenType, t, availableImports) + separator); + } + } + return builder.toString(); + } + /** * The method returns reference to highest (top parent) Generated Transfer * Object. @@ -1014,7 +257,7 @@ public final class GeneratorUtil { * extended then childTransportObject is returned. In * second case the method is recursive called until first case. */ - private static GeneratedTransferObject getTopParrentTransportObject(GeneratedTransferObject childTransportObject) { + public static GeneratedTransferObject getTopParrentTransportObject(GeneratedTransferObject childTransportObject) { if (childTransportObject == null) { throw new IllegalArgumentException("Parameter childTransportObject can't be null."); } @@ -1024,7 +267,28 @@ public final class GeneratorUtil { return getTopParrentTransportObject(childTransportObject.getExtends()); } } - + + /** + * The method selects from input list of properties only those which have + * read only attribute set to true. + * + * @param properties + * contains list of properties of generated transfer object + * @return subset of properties which have read only attribute + * set to true + */ + public static List resolveReadOnlyPropertiesFromTO(List properties) { + List readOnlyProperties = new ArrayList(); + if (properties != null) { + for (final GeneratedProperty property : properties) { + if (property.isReadOnly()) { + readOnlyProperties.add(property); + } + } + } + return readOnlyProperties; + } + /** * The method returns the list of the properties of all extending generated * transfer object from genTO to highest parent generated @@ -1035,62 +299,15 @@ public final class GeneratorUtil { * generated transfer object. In case when extension exists the * method is recursive called. */ - private static List getPropertiesOfAllParents(GeneratedTransferObject genTO) { + public static List getPropertiesOfAllParents(GeneratedTransferObject genTO) { List propertiesOfAllParents = new ArrayList(); - if (genTO != null) { - final List allPropertiesOfTO = genTO.getProperties(); + if (genTO.getExtends() != null) { + final List allPropertiesOfTO = genTO.getExtends().getProperties(); List readOnlyPropertiesOfTO = resolveReadOnlyPropertiesFromTO(allPropertiesOfTO); propertiesOfAllParents.addAll(readOnlyPropertiesOfTO); - if (genTO.getExtends() != null) { - propertiesOfAllParents.addAll(getPropertiesOfAllParents(genTO.getExtends())); - } + propertiesOfAllParents.addAll(getPropertiesOfAllParents(genTO.getExtends())); } return propertiesOfAllParents; } - - public static String createStaticInicializationBlock(GeneratedTransferObject genTransferObject, String indent) { - - final StringBuilder builder = new StringBuilder(); - - List constants = genTransferObject.getConstantDefinitions(); - for (Constant constant : constants) { - if (constant.getName() == null || constant.getType() == null || constant.getValue() == null) { - continue; - } - if (constant.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) { - final Object constValue = constant.getValue(); - List regularExpressions = new ArrayList<>(); - if (constValue instanceof List) { - builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP + "List" + GAP - + TypeConstants.PATTERN_CONSTANT_NAME + GAP + "=" + GAP + "Arrays.asList" + LB); - final List constantValues = (List) constValue; - int stringsCount = 0; - for (Object value : constantValues) { - if (value instanceof String) { - if (stringsCount > 0) { - builder.append(COMMA); - } - stringsCount++; - regularExpressions.add((String) value); - builder.append(DOUBLE_QUOTE + (String) value + DOUBLE_QUOTE); - } - } - builder.append(RB + SC + NL); - } - builder.append(indent + PRIVATE + GAP + STATIC + GAP + FINAL + GAP + "List" + GAP - + MEMBER_PATTERN_LIST + GAP + ASSIGN + GAP + "new ArrayList()" + GAP + SC + NL + NL); - - if (!regularExpressions.isEmpty()) { - builder.append(indent + STATIC + LCB + NL); - builder.append(indent + TAB + "for (String regEx : " + TypeConstants.PATTERN_CONSTANT_NAME + ") {" - + NL); - builder.append(indent + TAB + TAB + MEMBER_PATTERN_LIST + ".add(Pattern.compile(regEx))" + SC + NL); - builder.append(indent + TAB + RCB + NL); - builder.append(indent + RCB + NL + NL); - } - - } - } - return builder.toString(); - } + } diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceGenerator.java b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceGenerator.java index 27570ca77d..381b157578 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceGenerator.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceGenerator.java @@ -7,107 +7,26 @@ */ package org.opendaylight.controller.sal.java.api.generator; -import static org.opendaylight.controller.sal.java.api.generator.Constants.*; - import java.io.IOException; import java.io.StringWriter; import java.io.Writer; -import java.util.List; -import java.util.Map; -import org.opendaylight.controller.sal.binding.model.api.*; +import org.opendaylight.controller.sal.binding.model.api.CodeGenerator; +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject; +import org.opendaylight.controller.sal.binding.model.api.GeneratedType; +import org.opendaylight.controller.sal.binding.model.api.Type; public final class InterfaceGenerator implements CodeGenerator { - private Map imports; - private Map innerTypeImports; - - private String generateEnums(List enums) { - String result = ""; - if (enums != null) { - EnumGenerator enumGenerator = new EnumGenerator(); - for (Enumeration en : enums) { - try { - result = result + (enumGenerator.generateInnerEnumeration(en, TAB).toString() + NL); - } catch (IOException e) { - e.printStackTrace(); - } - } - } - return result; - } - - private String generateConstants(List constants, String pkgName) { - String result = ""; - if (constants != null) { - for (Constant c : constants) { - result = result + GeneratorUtil.createConstant(c, TAB, imports, pkgName) + NL; - } - result.concat(NL); - } - return result; - } - - public String generateMethods(List methods, String pkgName) { - String result = ""; - - if (methods != null) { - for (MethodSignature m : methods) { - result = result + GeneratorUtil.createMethodDeclaration(m, TAB, imports, pkgName) + NL; - } - result = result + NL; - } - return result; - } - - public String generateInnerClasses(final List generatedTypes) throws IOException { - String result = ""; - - if (generatedTypes != null) { - ClassCodeGenerator classCodeGenerator = new ClassCodeGenerator(); - for (GeneratedType genType : generatedTypes) { - if (genType instanceof GeneratedTransferObject) { - result = result + classCodeGenerator.generateOnlyClass(genType, imports).toString(); - result = result + NL + NL; - } - } - } - - return result; - } - + @Override public Writer generate(Type type) throws IOException { - Writer writer = new StringWriter(); + final Writer writer = new StringWriter(); if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) { final GeneratedType genType = (GeneratedType) type; - imports = GeneratorUtil.createImports(genType); - innerTypeImports = GeneratorUtil.createChildImports(genType); - - final String currentPkg = genType.getPackageName(); - final List constants = genType.getConstantDefinitions(); - final List methods = genType.getMethodDefinitions(); - final List enums = genType.getEnumerations(); - final List enclosedGeneratedTypes = genType.getEnclosedTypes(); - - writer.write(GeneratorUtil.createPackageDeclaration(genType.getPackageName())); - writer.write(NL); - - List importLines = GeneratorUtil.createImportLines(imports, innerTypeImports); - - for (String line : importLines) { - writer.write(line + NL); - } - writer.write(NL); - writer.write(GeneratorUtil.createIfcDeclaration(genType, "", imports)); - writer.write(NL); - - writer.write(generateInnerClasses(enclosedGeneratedTypes)); - writer.write(generateEnums(enums)); - writer.write(generateConstants(constants, currentPkg)); - writer.write(generateMethods(methods, currentPkg)); - - writer.write(RCB); + final InterfaceTemplate interfaceTemplate = new InterfaceTemplate(genType); + writer.write(interfaceTemplate.generate().toString()); } return writer; } + } diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceTemplate.xtend b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceTemplate.xtend new file mode 100644 index 0000000000..fb9d606272 --- /dev/null +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/InterfaceTemplate.xtend @@ -0,0 +1,153 @@ +package org.opendaylight.controller.sal.java.api.generator + +import java.util.List +import java.util.Map +import org.opendaylight.controller.binding.generator.util.TypeConstants +import org.opendaylight.controller.sal.binding.model.api.Constant +import org.opendaylight.controller.sal.binding.model.api.Enumeration +import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject +import org.opendaylight.controller.sal.binding.model.api.GeneratedType +import org.opendaylight.controller.sal.binding.model.api.MethodSignature +import org.opendaylight.controller.sal.binding.model.api.Type +import java.util.LinkedHashMap + +class InterfaceTemplate { + + val GeneratedType genType + val Map imports + val List consts + val List methods + val List enums + val List enclosedGeneratedTypes + + new(GeneratedType genType) { + if (genType == null) { + throw new IllegalArgumentException("Generated type reference cannot be NULL!") + } + + this.genType = genType + imports = GeneratorUtil.createImports(genType) + consts = genType.constantDefinitions + methods = genType.methodDefinitions + enums = genType.enumerations + enclosedGeneratedTypes = genType.enclosedTypes + } + + def generate() { + val body = generateBody + val pkgAndImports = generatePkgAndImports + return pkgAndImports.toString + body.toString + } + + def private generateBody() ''' + «genType.comment.generateComment» + «generateIfcDeclaration» { + + «generateInnerClasses» + + «generateEnums» + + «generateConstants» + + «generateMethods» + + } + + ''' + + def private generateComment(String comment) ''' + «IF comment != null && !comment.empty» + /* + «comment» + */ + «ENDIF» + ''' + + def private generateIfcDeclaration() ''' + public interface «genType.name»« + IF (!genType.implements.empty)»« + " extends "»« + FOR type : genType.implements SEPARATOR ", "»« + type.resolveName»« + ENDFOR»« + ENDIF + »''' + + def private generateInnerClasses() ''' + «IF !enclosedGeneratedTypes.empty» + «FOR innerClass : enclosedGeneratedTypes SEPARATOR "\n"» + «IF (innerClass instanceof GeneratedTransferObject)» + «val classTemplate = new ClassTemplate(innerClass as GeneratedTransferObject)» + «classTemplate.generateAsInnerClass» + «ENDIF» + «ENDFOR» + «ENDIF» + ''' + + def private generateEnums() ''' + «IF !enums.empty» + «FOR e : enums SEPARATOR "\n"» + «val enumTemplate = new EnumTemplate(e)» + «enumTemplate.generateAsInnerClass» + «ENDFOR» + «ENDIF» + ''' + + def private generateConstants() ''' + «IF !consts.empty» + «FOR c : consts» + «IF c.name != TypeConstants.PATTERN_CONSTANT_NAME» + public static final «c.type.resolveName» «c.name» = «c.value»; + «ENDIF» + «ENDFOR» + «ENDIF» + ''' + + def private generateMethods() ''' + «IF !methods.empty» + «FOR m : methods SEPARATOR "\n"» + «m.comment.generateComment» + «m.returnType.resolveName» «m.name»(«m.parameters.generateParameters»); + «ENDFOR» + «ENDIF» + ''' + + def private generateParameters(List parameters) '''« + IF !parameters.empty»« + FOR parameter : parameters SEPARATOR ", "»« + parameter.type.resolveName» «parameter.name»« + ENDFOR»« + ENDIF + »''' + + def private generatePkgAndImports() ''' + package «genType.packageName»; + + + «IF !imports.empty» + «FOR entry : resolveImports.entrySet» + import «entry.value».«entry.key»; + «ENDFOR» + «ENDIF» + + ''' + + def private Map resolveImports() { + val innerTypeImports = GeneratorUtil.createChildImports(genType) + val Map resolvedImports = new LinkedHashMap + for (Map.Entry entry : imports.entrySet() + innerTypeImports.entrySet) { + val typeName = entry.getKey(); + val packageName = entry.getValue(); + if (packageName != genType.packageName && packageName != genType.fullyQualifiedName) { + resolvedImports.put(typeName, packageName); + } + } + return resolvedImports + } + + def private resolveName(Type type) { + GeneratorUtil.putTypeIntoImports(genType, type, imports); + GeneratorUtil.getExplicitType(genType, type, imports) + } + +} \ No newline at end of file diff --git a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/controller/sal/java/api/generator/test/ClassCodeGeneratorTest.java b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/controller/sal/java/api/generator/test/ClassCodeGeneratorTest.java index 54856d1403..3f41f1e134 100644 --- a/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/controller/sal/java/api/generator/test/ClassCodeGeneratorTest.java +++ b/opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/test/java/org/opendaylight/controller/sal/java/api/generator/test/ClassCodeGeneratorTest.java @@ -21,7 +21,7 @@ import org.opendaylight.controller.sal.binding.model.api.GeneratedType; import org.opendaylight.controller.sal.binding.model.api.Type; import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedPropertyBuilder; import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder; -import org.opendaylight.controller.sal.java.api.generator.ClassCodeGenerator; +import org.opendaylight.controller.sal.java.api.generator.ClassGenerator; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser; @@ -72,7 +72,7 @@ public class ClassCodeGeneratorTest { } } - final ClassCodeGenerator clsGen = new ClassCodeGenerator(); + final ClassGenerator clsGen = new ClassGenerator(); try { final Writer writer = clsGen.generate(genTO); assertNotNull(writer); @@ -119,7 +119,7 @@ public class ClassCodeGeneratorTest { final GeneratedTransferObject genTO = toBuilder.toInstance(); - final ClassCodeGenerator clsGen = new ClassCodeGenerator(); + final ClassGenerator clsGen = new ClassGenerator(); try { final Writer writer = clsGen.generate(genTO); assertNotNull(writer); @@ -150,7 +150,7 @@ public class ClassCodeGeneratorTest { propBuilder.setReadOnly(false); toBuilder.addToStringProperty(propBuilder); final GeneratedTransferObject genTO = toBuilder.toInstance(); - final ClassCodeGenerator clsGen = new ClassCodeGenerator(); + final ClassGenerator clsGen = new ClassGenerator(); try { final Writer writer = clsGen.generate(genTO); assertNotNull(writer); -- 2.36.6