X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fsal%2Fyang-prototype%2Fcode-generator%2Fbinding-java-api-generator%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fjava%2Fapi%2Fgenerator%2FGeneratorUtil.java;h=ec908560e4108ced2b832b57887b1afce26d91bf;hp=b4387fe8034b19b3d9856a84791f4f265d7e0cd3;hb=c9006d027a5c5b639e57aa7b8484ec1ff3497dc8;hpb=4221068644c7e8d08880b4d54e2a099a646796b9 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 b4387fe803..ec908560e4 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,68 +7,85 @@ */ package org.opendaylight.controller.sal.java.api.generator; -import static org.opendaylight.controller.sal.java.api.generator.Constants.CLASS; -import static org.opendaylight.controller.sal.java.api.generator.Constants.COMMA; -import static org.opendaylight.controller.sal.java.api.generator.Constants.ENUM; -import static org.opendaylight.controller.sal.java.api.generator.Constants.FINAL; -import static org.opendaylight.controller.sal.java.api.generator.Constants.GAP; -import static org.opendaylight.controller.sal.java.api.generator.Constants.IFC; -import static org.opendaylight.controller.sal.java.api.generator.Constants.LB; -import static org.opendaylight.controller.sal.java.api.generator.Constants.LCB; -import static org.opendaylight.controller.sal.java.api.generator.Constants.NL; -import static org.opendaylight.controller.sal.java.api.generator.Constants.PKG; -import static org.opendaylight.controller.sal.java.api.generator.Constants.PRIVATE; -import static org.opendaylight.controller.sal.java.api.generator.Constants.PUBLIC; -import static org.opendaylight.controller.sal.java.api.generator.Constants.RB; -import static org.opendaylight.controller.sal.java.api.generator.Constants.RCB; -import static org.opendaylight.controller.sal.java.api.generator.Constants.SC; -import static org.opendaylight.controller.sal.java.api.generator.Constants.STATIC; -import static org.opendaylight.controller.sal.java.api.generator.Constants.TAB; +import static org.opendaylight.controller.sal.java.api.generator.Constants.*; +import java.util.ArrayList; +import java.util.LinkedHashMap; import java.util.List; +import java.util.Map; -import org.opendaylight.controller.sal.binding.model.api.AnnotationType; -import org.opendaylight.controller.sal.binding.model.api.Constant; -import org.opendaylight.controller.sal.binding.model.api.Enumeration; +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.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.MethodSignature.Parameter; -import org.opendaylight.controller.sal.binding.model.api.ParameterizedType; -import org.opendaylight.controller.sal.binding.model.api.Type; -public class GeneratorUtil { +public final class GeneratorUtil { private GeneratorUtil() { } - public static String createIfcDeclarationWithPkgName( - final GeneratedType genType, final String indent) { - return createFileDeclarationWithPkgName(IFC, genType, indent); + public static String createIfcDeclaration(final GeneratedType genType, final String indent, + final Map availableImports) { + return createFileDeclaration(IFC, genType, indent, availableImports, false); } - public static String createClassDeclarationWithPkgName( - final GeneratedTransferObject genTransferObject, final String indent) { - return createFileDeclarationWithPkgName(CLASS, genTransferObject, - indent); + public static String createClassDeclaration(final GeneratedTransferObject genTransferObject, final String indent, + final Map availableImports, boolean isIdentity) { + return createFileDeclaration(CLASS, genTransferObject, indent, availableImports, isIdentity); } - private static String createFileDeclarationWithPkgName(final String type, - final GeneratedType genType, final String indent) { + 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) { final StringBuilder builder = new StringBuilder(); - builder.append(PKG + GAP + genType.getPackageName() + SC); - builder.append(NL); - builder.append(NL); + 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); } - builder.append(PUBLIC + GAP + type + GAP + genType.getName() + GAP - + LCB); + + if (isIdentity) { + if (!(CLASS.equals(type))) { + throw new IllegalArgumentException("'identity' has to be generated as a class"); + } + builder.append(PUBLIC + GAP + ABSTRACT + GAP + type + GAP + genType.getName() + GAP); + } else { + builder.append(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(); } @@ -82,8 +99,7 @@ public class GeneratorUtil { if (annotation.containsParameters()) { builder.append("("); - final List parameters = annotation - .getParameters(); + final List parameters = annotation.getParameters(); appendAnnotationParams(builder, parameters); builder.append(")"); } @@ -92,8 +108,7 @@ public class GeneratorUtil { return builder; } - private static StringBuilder appendAnnotationParams( - final StringBuilder builder, + private static StringBuilder appendAnnotationParams(final StringBuilder builder, final List parameters) { if (parameters != null) { int i = 0; @@ -126,28 +141,52 @@ public class GeneratorUtil { return builder; } - public static String createConstant(final Constant constant, - final String indent) { + 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()) + GAP - + constant.getName()); + builder.append(getExplicitType(constant.getType(), availableImports, currentPkg) + GAP + constant.getName()); builder.append(GAP + "=" + GAP); - builder.append(constant.getValue() + SC); + final Object constValue = constant.getValue(); + + if (constant.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) { + if (constant.getName() == null || constant.getType() == null || constant.getValue() == null) + throw new IllegalArgumentException(); + if (constValue instanceof List) { + builder.append("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++; + builder.append(DOUBLE_QUOTE + (String) value + DOUBLE_QUOTE); + } + } + builder.append(RB); + } + } else { + builder.append(constant.getValue()); + } + builder.append(SC); + return builder.toString(); } - public static String createField(final GeneratedProperty property, - final String indent) { + public static String createField(final GeneratedProperty property, final String indent, + final Map availableImports, final String currentPkg) { final StringBuilder builder = new StringBuilder(); - builder.append(indent); 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()) + GAP + builder.append(getExplicitType(property.getReturnType(), availableImports, currentPkg) + GAP + property.getName()); builder.append(SC); return builder.toString(); @@ -160,25 +199,38 @@ public class GeneratorUtil { * @param indent * @return */ - public static String createMethodDeclaration(final MethodSignature method, - final String indent) { + 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 Type type = method.getReturnType(); 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(); - final StringBuilder builder = new StringBuilder(); createComment(builder, comment, indent); builder.append(NL); builder.append(indent); - + if (!method.getAnnotations().isEmpty()) { final List annotations = method.getAnnotations(); appendAnnotations(builder, annotations); builder.append(NL); } - - builder.append(indent + getExplicitType(type) + GAP + name); + + 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); @@ -186,8 +238,7 @@ public class GeneratorUtil { if (i + 1 == parameters.size()) { separator = ""; } - builder.append(getExplicitType(p.getType()) + GAP + p.getName() - + separator); + builder.append(getExplicitType(p.getType(), availableImports, currentPkg) + GAP + p.getName() + separator); } builder.append(RB); builder.append(SC); @@ -195,46 +246,42 @@ public class GeneratorUtil { return builder.toString(); } - public static String createConstructor( - GeneratedTransferObject genTransferObject, final String indent) { + public static String createConstructor(GeneratedTransferObject genTransferObject, final String indent, + final Map availableImports, boolean isIdentity) { final StringBuilder builder = new StringBuilder(); - final List properties = genTransferObject - .getProperties(); - builder.append(indent); - builder.append(PUBLIC); - builder.append(GAP); - builder.append(genTransferObject.getName()); - builder.append(LB); - - boolean first = true; + final String currentPkg = genTransferObject.getPackageName(); + final List properties = genTransferObject.getProperties(); + final List ctorParams = new ArrayList(); if (properties != null) { for (final GeneratedProperty property : properties) { - if (first) { - builder.append(getExplicitType(property.getReturnType())); - builder.append(" "); - builder.append(property.getName()); - first = false; - } else { - builder.append(", "); - builder.append(getExplicitType(property.getReturnType())); - builder.append(builder.append(" ")); - builder.append(property.getName()); + if (property.isReadOnly()) { + ctorParams.add(property); } } } - builder.append(RB); - builder.append(GAP); - builder.append(LCB); - builder.append(NL); builder.append(indent); - builder.append(TAB); - builder.append("super();"); - builder.append(NL); + builder.append(isIdentity ? PROTECTED : PUBLIC); + builder.append(GAP); + builder.append(genTransferObject.getName()); + builder.append(LB); - if (properties != null) { - for (final GeneratedProperty property : properties) { + if (!ctorParams.isEmpty()) { + builder.append(getExplicitType(ctorParams.get(0).getReturnType(), availableImports, currentPkg)); + builder.append(" "); + builder.append(ctorParams.get(0).getName()); + for (int i = 1; i < ctorParams.size(); ++i) { + final GeneratedProperty param = ctorParams.get(i); + builder.append(", "); + builder.append(getExplicitType(param.getReturnType(), availableImports, currentPkg)); + builder.append(GAP); + builder.append(param.getName()); + } + } + builder.append(RB + GAP + LCB + NL + indent + TAB + "super();" + NL); + if (!ctorParams.isEmpty()) { + for (final GeneratedProperty property : ctorParams) { builder.append(indent); builder.append(TAB); builder.append("this."); @@ -245,15 +292,37 @@ public class GeneratorUtil { builder.append(NL); } } + List consts = genTransferObject.getConstantDefinitions(); + for (Constant con : consts) { + if (con.getName() == null || con.getType() == null || con.getValue() == null) + continue; + if (con.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) { + Object values = con.getValue(); + if (values instanceof List) { + for (Object regEx : (List) values) { + if (regEx instanceof String) { + builder.append(indent + TAB + "for (String regEx : " + TypeConstants.PATTERN_CONSTANT_NAME + + ") {" + NL); + builder.append(indent + TAB + TAB + "this." + MEMBER_PATTERN_LIST + + ".add(Pattern.compile(regEx))" + SC + NL); + builder.append(indent + TAB + RCB + NL); + + break; + } + } + + } + } + + } builder.append(indent); builder.append(RCB); - return builder.toString(); } - public static String createGetter(final GeneratedProperty property, - final String indent) { + 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(); @@ -261,8 +330,7 @@ public class GeneratorUtil { final char first = Character.toUpperCase(varName.charAt(0)); final String methodName = "get" + first + varName.substring(1); - builder.append(indent + PUBLIC + GAP + getExplicitType(type) + GAP - + methodName); + builder.append(indent + PUBLIC + GAP + getExplicitType(type, availableImports, currentPkg) + GAP + methodName); builder.append(LB + RB + LCB + NL); String currentIndent = indent + TAB; @@ -273,8 +341,24 @@ public class GeneratorUtil { return builder.toString(); } - public static String createHashCode( - final List properties, final String indent) { + 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); @@ -282,8 +366,7 @@ public class GeneratorUtil { for (GeneratedProperty property : properties) { String fieldName = property.getName(); - builder.append(indent + TAB + "result = prime * result + ((" - + fieldName + " == null) ? 0 : " + fieldName + builder.append(indent + TAB + "result = prime * result + ((" + fieldName + " == null) ? 0 : " + fieldName + ".hashCode());" + NL); } @@ -292,12 +375,12 @@ public class GeneratorUtil { return builder.toString(); } - public static String createEquals(final GeneratedTransferObject type, - final List properties, final String indent) { - StringBuilder builder = new StringBuilder(); + 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 = indent + TAB + TAB; - final String indent3 = indent + TAB + TAB + 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); @@ -310,31 +393,27 @@ public class GeneratorUtil { builder.append(indent2 + "return false;" + NL); builder.append(indent1 + "}" + NL); - String typeStr = type.getPackageName() + "." + type.getName(); - builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;" - + NL); + String typeStr = type.getName(); + builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;" + NL); - for (GeneratedProperty property : properties) { + 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(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(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) { + 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() {"); @@ -350,7 +429,7 @@ public class GeneratorUtil { builder.append(" ["); boolean first = true; - for (GeneratedProperty property : properties) { + for (final GeneratedProperty property : properties) { if (first) { builder.append(property.getName()); builder.append("=\");"); @@ -371,7 +450,7 @@ public class GeneratorUtil { builder.append(NL); builder.append(indent); builder.append(TAB); - builder.append("builder.append(\", "); + builder.append("builder.append("); builder.append(property.getName()); builder.append(");"); } @@ -392,61 +471,112 @@ public class GeneratorUtil { return builder.toString(); } - public static String createEnum(final Enumeration enumeration, - final String indent) { - final StringBuilder builder = new StringBuilder(indent + ENUM + GAP - + enumeration.getName() + GAP + LCB + NL); + 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; + String separator = COMMA + NL; final List values = enumeration.getValues(); - builder.append(indent + TAB); + for (int i = 0; i < values.size(); i++) { if (i + 1 == values.size()) { separator = SC; } - builder.append(values.get(i).getName() + separator); + 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) { - String packageName = type.getPackageName(); - if (packageName.endsWith(".")) { - packageName = packageName.substring(0, packageName.length() - 1); + 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!"); } - final StringBuilder builder = new StringBuilder(packageName + "." - + type.getName()); - if (type instanceof ParameterizedType) { - ParameterizedType pType = (ParameterizedType) type; - Type[] pTypes = pType.getActualTypeArguments(); - builder.append("<"); - builder.append(getParameters(pTypes)); - builder.append(">"); + if (type.getName() == null) { + throw new IllegalArgumentException("Type name cannot be NULL!"); } - if (builder.toString().equals("java.lang.Void")) { - return "void"; + 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 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(); } - return builder.toString(); } - private static String getParameters(final Type[] pTypes) { + private static String getParameters(final Type[] pTypes, Map availableImports, String currentPkg) { final StringBuilder builder = new StringBuilder(); for (int i = 0; i < pTypes.length; i++) { - Type t = pTypes[i]; + final Type t = pTypes[i]; String separator = COMMA; - if (i + 1 == pTypes.length) { + if (i == (pTypes.length - 1)) { separator = ""; } - builder.append(getExplicitType(t) + separator); + + String wildcardParam = ""; + 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) { + 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); @@ -454,4 +584,129 @@ public class GeneratorUtil { } } + public static Map createImports(final GeneratedType genType) { + if (genType == null) { + throw new IllegalArgumentException("Generated Type cannot be NULL!"); + } + + final Map imports = new LinkedHashMap<>(); + final List constants = genType.getConstantDefinitions(); + final List methods = genType.getMethodDefinitions(); + final List impl = genType.getImplements(); + + // IMPLEMENTATIONS + if (impl != null) { + for (final Type type : impl) { + putTypeIntoImports(genType, type, imports); + } + } + + // CONSTANTS + if (constants != null) { + for (final Constant constant : constants) { + final Type constantType = constant.getType(); + putTypeIntoImports(genType, constantType, imports); + } + } + + // REGULAR EXPRESSION + if (genType instanceof GeneratedTransferObject) { + if (isConstantInTO(TypeConstants.PATTERN_CONSTANT_NAME, (GeneratedTransferObject) genType)) { + putTypeIntoImports(genType, Types.typeForClass(java.util.regex.Pattern.class), imports); + putTypeIntoImports(genType, Types.typeForClass(java.util.Arrays.class), imports); + putTypeIntoImports(genType, Types.typeForClass(java.util.ArrayList.class), imports); + } + } + + // METHODS + if (methods != null) { + for (final MethodSignature method : methods) { + final Type methodReturnType = method.getReturnType(); + putTypeIntoImports(genType, methodReturnType, imports); + for (final MethodSignature.Parameter methodParam : method.getParameters()) { + putTypeIntoImports(genType, methodParam.getType(), imports); + } + } + } + + // PROPERTIES + if (genType instanceof GeneratedTransferObject) { + final GeneratedTransferObject genTO = (GeneratedTransferObject) genType; + final List properties = genTO.getProperties(); + if (properties != null) { + for (GeneratedProperty property : properties) { + final Type propertyType = property.getReturnType(); + putTypeIntoImports(genType, propertyType, imports); + } + } + } + + return imports; + } + + private 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 " + + "NULL!"); + } + if (parentGenType.getName() == null) { + throw new IllegalArgumentException("Parent Generated Type name cannot be NULL!"); + } + if (parentGenType.getPackageName() == null) { + throw new IllegalArgumentException("Parent Generated Type cannot have Package Name referenced as NULL!"); + } + 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!"); + } + + final String typeName = type.getName(); + final String typePackageName = type.getPackageName(); + final String parentTypeName = parentGenType.getName(); + final String parentTypePackageName = parentGenType.getPackageName(); + if (typeName.equals(parentTypeName) || typePackageName.startsWith("java.lang") + || typePackageName.equals(parentTypePackageName) || typePackageName.isEmpty()) { + return; + } + if (!imports.containsKey(typeName)) { + imports.put(typeName, typePackageName); + } + if (type instanceof ParameterizedType) { + final ParameterizedType paramType = (ParameterizedType) type; + final Type[] params = paramType.getActualTypeArguments(); + for (Type param : params) { + putTypeIntoImports(parentGenType, param, imports); + } + } + } + + public static List createImportLines(final Map imports) { + final List importLines = new ArrayList<>(); + + for (Map.Entry entry : imports.entrySet()) { + final String typeName = entry.getKey(); + final String packageName = entry.getValue(); + importLines.add("import " + packageName + "." + typeName + SC); + } + return importLines; + } + + public static boolean isConstantInTO(String constName, GeneratedTransferObject genTO) { + if (constName == null || genTO == null) + throw new IllegalArgumentException(); + List consts = genTO.getConstantDefinitions(); + for (Constant cons : consts) { + if (cons.getName().equals(constName)) { + return true; + } + + } + return false; + } }