X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?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=804ac99ff26138d1e36d18c6dbbd99755fc1b946;hb=84ca16196357ad899e00eceae27ef75eaf899d14;hp=9e9a3e5df1dcabb339e250ff1ec0ba5c11e78153;hpb=fb99d767417ba5a92c24412aa15ddb56f1f292a3;p=controller.git 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 9e9a3e5df1..804ac99ff2 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,28 +7,13 @@ */ 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.EXTENDS; -import static org.opendaylight.controller.sal.java.api.generator.Constants.IMPLEMENTS; +import static org.opendaylight.controller.sal.java.api.generator.Constants.*; import java.util.ArrayList; +import java.util.HashMap; +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; @@ -41,29 +26,40 @@ 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; +import org.opendaylight.controller.sal.binding.model.api.WildcardType; -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()) { @@ -71,27 +67,42 @@ public class GeneratorUtil { appendAnnotations(builder, annotations); builder.append(NL); } - builder.append(PUBLIC + GAP + type + GAP + genType.getName() + GAP); - final List genImplements = genType.getImplements(); + 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); - builder.append(genTO.getExtends() + 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))); + builder.append(getExplicitType(genImplements.get(0), + availableImports, currentPkg)); + for (int i = 1; i < genImplements.size(); ++i) { builder.append(", "); - builder.append(getExplicitType(genImplements.get(i))); + builder.append(getExplicitType(genImplements.get(i), + availableImports, currentPkg)); } } @@ -155,28 +166,31 @@ public class GeneratorUtil { } public static String createConstant(final Constant constant, - final String indent) { + final String indent, + final Map> availableImports, + final String currentPkg) { final StringBuilder builder = new StringBuilder(); 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); return builder.toString(); } public static String createField(final GeneratedProperty property, - final String indent) { + final String indent, + 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 - + property.getName()); + builder.append(getExplicitType(property.getReturnType(), + availableImports, currentPkg) + GAP + property.getName()); builder.append(SC); return builder.toString(); } @@ -189,9 +203,14 @@ public class GeneratorUtil { * @return */ public static String createMethodDeclaration(final MethodSignature method, - final String indent) { + 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!"); + throw new IllegalArgumentException( + "Method Signature parameter MUST be specified and cannot be NULL!"); } final String comment = method.getComment(); @@ -202,12 +221,12 @@ public class GeneratorUtil { final Type type = method.getReturnType(); if (type == null) { - throw new IllegalStateException("Method Return type cannot be 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); @@ -218,7 +237,9 @@ public class GeneratorUtil { 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); @@ -226,8 +247,8 @@ 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); @@ -236,9 +257,12 @@ public class GeneratorUtil { } public static String createConstructor( - GeneratedTransferObject genTransferObject, final String indent) { + GeneratedTransferObject genTransferObject, final String indent, + Map> availableImports, + boolean isIdentity) { final StringBuilder builder = new StringBuilder(); + final String currentPkg = genTransferObject.getPackageName(); final List properties = genTransferObject .getProperties(); final List ctorParams = new ArrayList(); @@ -247,21 +271,23 @@ public class GeneratorUtil { ctorParams.add(property); } } - + builder.append(indent); - builder.append(PUBLIC); + builder.append(isIdentity ? PROTECTED : PUBLIC); builder.append(GAP); builder.append(genTransferObject.getName()); builder.append(LB); - + if (!ctorParams.isEmpty()) { - builder.append(getExplicitType(ctorParams.get(0).getReturnType())); + 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())); + builder.append(getExplicitType(param.getReturnType(), + availableImports, currentPkg)); builder.append(GAP); builder.append(param.getName()); } @@ -285,7 +311,9 @@ public class GeneratorUtil { } public static String createGetter(final GeneratedProperty property, - final String indent) { + final String indent, + Map> availableImports, + final String currentPkg) { final StringBuilder builder = new StringBuilder(); final Type type = property.getReturnType(); @@ -293,7 +321,8 @@ 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 + builder.append(indent + PUBLIC + GAP + + getExplicitType(type, availableImports, currentPkg) + GAP + methodName); builder.append(LB + RB + LCB + NL); @@ -304,9 +333,11 @@ public class GeneratorUtil { builder.append(indent + RCB); return builder.toString(); } - + public static String createSetter(final GeneratedProperty property, - final String indent) { + final String indent, + Map> availableImports, + String currentPkg) { final StringBuilder builder = new StringBuilder(); final Type type = property.getReturnType(); @@ -314,11 +345,12 @@ public class GeneratorUtil { 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) + GAP + varName + RB + LCB + NL); + 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(currentIndent + "this." + varName + " = " + varName + SC + + NL); builder.append(indent + RCB); return builder.toString(); } @@ -329,7 +361,7 @@ public class GeneratorUtil { 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 + ((" @@ -346,8 +378,8 @@ public class GeneratorUtil { final List properties, final String indent) { 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); @@ -360,7 +392,7 @@ public class GeneratorUtil { builder.append(indent2 + "return false;" + NL); builder.append(indent1 + "}" + NL); - String typeStr = type.getPackageName() + "." + type.getName(); + String typeStr = type.getName(); builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;" + NL); @@ -421,7 +453,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(");"); } @@ -444,48 +476,98 @@ public class GeneratorUtil { public static String createEnum(final Enumeration enumeration, final String indent) { - final StringBuilder builder = new StringBuilder(indent + ENUM + GAP - + enumeration.getName() + GAP + LCB + NL); + 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) { + private static String getExplicitType(final Type type, + Map> availableImports, + final String currentPkg) { if (type == null) { - throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!"); + throw new IllegalArgumentException( + "Type parameter MUST be specified and cannot be NULL!"); } String packageName = type.getPackageName(); - if (packageName.endsWith(".")) { - packageName = packageName.substring(0, packageName.length() - 1); - } - final StringBuilder builder = new StringBuilder(packageName + "." - + type.getName()); - if (type instanceof ParameterizedType) { - final ParameterizedType pType = (ParameterizedType) type; - Type[] pTypes = pType.getActualTypeArguments(); - builder.append("<"); - builder.append(getParameters(pTypes)); - builder.append(">"); - } - if (builder.toString().equals("java.lang.Void")) { - return "void"; + LinkedHashMap imports = availableImports.get(type + .getName()); + + if ((imports != null && packageName + .equals(findMaxValue(imports).get(0))) + || packageName.equals(currentPkg)) { + final StringBuilder builder = new StringBuilder(type.getName()); + if (type instanceof ParameterizedType) { + ParameterizedType pType = (ParameterizedType) type; + Type[] pTypes = pType.getActualTypeArguments(); + builder.append("<"); + builder.append(getParameters(pTypes, availableImports, + currentPkg)); + builder.append(">"); + } + if (builder.toString().equals("Void")) { + return "void"; + } + return builder.toString(); + } else { + final StringBuilder builder = new StringBuilder(); + if (packageName.startsWith("java.lang")) { + builder.append(type.getName()); + } else { + if (!packageName.isEmpty()) { + builder.append(packageName + "." + type.getName()); + } else { + builder.append(type.getName()); + } + + } + if (type instanceof ParameterizedType) { + ParameterizedType pType = (ParameterizedType) type; + Type[] pTypes = pType.getActualTypeArguments(); + builder.append("<"); + builder.append(getParameters(pTypes, availableImports, + 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]; @@ -494,11 +576,37 @@ public class GeneratorUtil { if (i + 1 == pTypes.length) { 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 List findMaxValue( + LinkedHashMap imports) { + final List result = new ArrayList(); + + int maxValue = 0; + int currentValue = 0; + for (Map.Entry entry : imports.entrySet()) { + currentValue = entry.getValue(); + if (currentValue > maxValue) { + result.clear(); + result.add(entry.getKey()); + maxValue = currentValue; + } else if (currentValue == maxValue) { + result.add(entry.getKey()); + } + } + return result; + } + private static void createComment(final StringBuilder builder, final String comment, final String indent) { if (comment != null && comment.length() > 0) { @@ -508,4 +616,102 @@ public class GeneratorUtil { } } + public static Map> createImports( + GeneratedType genType) { + final Map> imports = new HashMap>(); + final String genTypePkg = genType.getPackageName(); + + final List constants = genType.getConstantDefinitions(); + final List methods = genType.getMethodDefinitions(); + List impl = genType.getImplements(); + + // IMPLEMENTATIONS + if (impl != null) { + for (Type t : impl) { + addTypeToImports(t, imports, genTypePkg); + } + } + + // CONSTANTS + if (constants != null) { + for (Constant c : constants) { + Type ct = c.getType(); + addTypeToImports(ct, imports, genTypePkg); + } + } + + // METHODS + if (methods != null) { + for (MethodSignature m : methods) { + Type ct = m.getReturnType(); + addTypeToImports(ct, imports, genTypePkg); + for (MethodSignature.Parameter p : m.getParameters()) { + addTypeToImports(p.getType(), imports, genTypePkg); + } + } + } + + // PROPERTIES + if (genType instanceof GeneratedTransferObject) { + GeneratedTransferObject genTO = (GeneratedTransferObject) genType; + + List props = genTO.getProperties(); + if (props != null) { + for (GeneratedProperty prop : props) { + Type pt = prop.getReturnType(); + addTypeToImports(pt, imports, genTypePkg); + } + } + } + + return imports; + } + + private static void addTypeToImports(Type type, + Map> importedTypes, + String genTypePkg) { + String typeName = type.getName(); + String typePkg = type.getPackageName(); + if (typePkg.startsWith("java.lang") || typePkg.equals(genTypePkg) || + typePkg.isEmpty()) { + return; + } + LinkedHashMap packages = importedTypes.get(typeName); + if (packages == null) { + packages = new LinkedHashMap(); + packages.put(typePkg, 1); + importedTypes.put(typeName, packages); + } else { + Integer occurrence = packages.get(typePkg); + if (occurrence == null) { + packages.put(typePkg, 1); + } else { + occurrence++; + packages.put(typePkg, occurrence); + } + } + + if (type instanceof ParameterizedType) { + ParameterizedType pt = (ParameterizedType) type; + Type[] params = pt.getActualTypeArguments(); + for (Type param : params) { + addTypeToImports(param, importedTypes, genTypePkg); + } + } + } + + public static List createImportLines( + Map> imports) { + List importLines = new ArrayList(); + + for (Map.Entry> entry : imports + .entrySet()) { + String typeName = entry.getKey(); + LinkedHashMap typePkgMap = entry.getValue(); + String typePkg = typePkgMap.keySet().iterator().next(); + importLines.add("import " + typePkg + "." + typeName + SC); + } + return importLines; + } + }