2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.sal.java.api.generator;
10 import static org.opendaylight.controller.sal.java.api.generator.Constants.*;
12 import java.util.ArrayList;
13 import java.util.HashMap;
14 import java.util.LinkedHashMap;
15 import java.util.List;
18 import org.opendaylight.controller.binding.generator.util.TypeConstants;
19 import org.opendaylight.controller.binding.generator.util.Types;
20 import org.opendaylight.controller.sal.binding.model.api.AnnotationType;
21 import org.opendaylight.controller.sal.binding.model.api.Constant;
22 import org.opendaylight.controller.sal.binding.model.api.Enumeration;
23 import org.opendaylight.controller.sal.binding.model.api.Enumeration.Pair;
24 import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty;
25 import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
26 import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
27 import org.opendaylight.controller.sal.binding.model.api.MethodSignature;
28 import org.opendaylight.controller.sal.binding.model.api.MethodSignature.Parameter;
29 import org.opendaylight.controller.sal.binding.model.api.ParameterizedType;
30 import org.opendaylight.controller.sal.binding.model.api.Type;
31 import org.opendaylight.controller.sal.binding.model.api.WildcardType;
33 public final class GeneratorUtil {
35 private GeneratorUtil() {
38 public static String createIfcDeclaration(final GeneratedType genType, final String indent,
39 final Map<String, LinkedHashMap<String, Integer>> availableImports) {
40 return createFileDeclaration(IFC, genType, indent, availableImports, false);
43 public static String createClassDeclaration(final GeneratedTransferObject genTransferObject, final String indent,
44 final Map<String, LinkedHashMap<String, Integer>> availableImports, boolean isIdentity) {
45 return createFileDeclaration(CLASS, genTransferObject, indent, availableImports, isIdentity);
48 public static String createPackageDeclaration(final String packageName) {
49 return PKG + GAP + packageName + SC;
52 private static String createFileDeclaration(final String type, final GeneratedType genType, final String indent,
53 final Map<String, LinkedHashMap<String, Integer>> availableImports, boolean isIdentity) {
54 final StringBuilder builder = new StringBuilder();
55 final String currentPkg = genType.getPackageName();
57 createComment(builder, genType.getComment(), indent);
59 if (!genType.getAnnotations().isEmpty()) {
60 final List<AnnotationType> annotations = genType.getAnnotations();
61 appendAnnotations(builder, annotations);
66 if (!(CLASS.equals(type))) {
67 throw new IllegalArgumentException("'identity' has to be generated as a class");
69 builder.append(PUBLIC + GAP + ABSTRACT + GAP + type + GAP + genType.getName() + GAP);
71 builder.append(PUBLIC + GAP + type + GAP + genType.getName() + GAP);
74 if (genType instanceof GeneratedTransferObject) {
75 GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
77 if (genTO.getExtends() != null) {
78 builder.append(EXTENDS + GAP);
79 String gtoString = getExplicitType(genTO.getExtends(), availableImports, currentPkg);
80 builder.append(gtoString + GAP);
84 final List<Type> genImplements = genType.getImplements();
85 if (!genImplements.isEmpty()) {
86 if (genType instanceof GeneratedTransferObject) {
87 builder.append(IMPLEMENTS + GAP);
89 builder.append(EXTENDS + GAP);
91 builder.append(getExplicitType(genImplements.get(0), availableImports, currentPkg));
93 for (int i = 1; i < genImplements.size(); ++i) {
95 builder.append(getExplicitType(genImplements.get(i), availableImports, currentPkg));
99 builder.append(GAP + LCB);
100 return builder.toString();
103 private static StringBuilder appendAnnotations(final StringBuilder builder, final List<AnnotationType> annotations) {
104 if ((builder != null) && (annotations != null)) {
105 for (final AnnotationType annotation : annotations) {
107 builder.append(annotation.getPackageName());
109 builder.append(annotation.getName());
111 if (annotation.containsParameters()) {
113 final List<AnnotationType.Parameter> parameters = annotation.getParameters();
114 appendAnnotationParams(builder, parameters);
122 private static StringBuilder appendAnnotationParams(final StringBuilder builder,
123 final List<AnnotationType.Parameter> parameters) {
124 if (parameters != null) {
126 for (final AnnotationType.Parameter param : parameters) {
131 builder.append(", ");
133 final String paramName = param.getName();
134 if (param.getValue() != null) {
135 builder.append(paramName);
136 builder.append(" = ");
137 builder.append(param.getValue());
139 builder.append(paramName);
140 builder.append(" = {");
141 final List<String> values = param.getValues();
142 builder.append(values.get(0));
143 for (int j = 1; j < values.size(); ++j) {
144 builder.append(", ");
145 builder.append(values.get(j));
155 public static String createConstant(final Constant constant, final String indent,
156 final Map<String, LinkedHashMap<String, Integer>> availableImports, final String currentPkg) {
157 final StringBuilder builder = new StringBuilder();
158 if (constant == null)
159 throw new IllegalArgumentException();
160 builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP);
161 builder.append(getExplicitType(constant.getType(), availableImports, currentPkg) + GAP + constant.getName());
162 builder.append(GAP + "=" + GAP);
163 final Object constValue = constant.getValue();
165 if (constant.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) {
166 if (constant.getName() == null || constant.getType() == null || constant.getValue() == null)
167 throw new IllegalArgumentException();
168 if (constValue instanceof List) {
169 builder.append("Arrays.asList" + LB);
170 final List<?> constantValues = (List<?>) constValue;
171 int stringsCount = 0;
172 for (Object value : constantValues) {
173 if (value instanceof String) {
174 if (stringsCount > 0) {
175 builder.append(COMMA);
178 builder.append(DOUBLE_QUOTE + (String) value + DOUBLE_QUOTE);
184 builder.append(constant.getValue());
188 return builder.toString();
191 public static String createField(final GeneratedProperty property, final String indent,
192 Map<String, LinkedHashMap<String, Integer>> availableImports, final String currentPkg) {
193 final StringBuilder builder = new StringBuilder();
194 if (!property.getAnnotations().isEmpty()) {
195 final List<AnnotationType> annotations = property.getAnnotations();
196 appendAnnotations(builder, annotations);
199 builder.append(indent + PRIVATE + GAP);
200 builder.append(getExplicitType(property.getReturnType(), availableImports, currentPkg) + GAP
201 + property.getName());
203 return builder.toString();
207 * Create method declaration in interface.
213 public static String createMethodDeclaration(final MethodSignature method, final String indent,
214 Map<String, LinkedHashMap<String, Integer>> availableImports, final String currentPkg) {
215 final StringBuilder builder = new StringBuilder();
217 if (method == null) {
218 throw new IllegalArgumentException("Method Signature parameter MUST be specified and cannot be NULL!");
221 final String comment = method.getComment();
222 final String name = method.getName();
224 throw new IllegalStateException("Method Name cannot be NULL!");
227 final Type type = method.getReturnType();
229 throw new IllegalStateException("Method Return type cannot be NULL!");
232 final List<Parameter> parameters = method.getParameters();
234 createComment(builder, comment, indent);
236 builder.append(indent);
238 if (!method.getAnnotations().isEmpty()) {
239 final List<AnnotationType> annotations = method.getAnnotations();
240 appendAnnotations(builder, annotations);
244 builder.append(indent + getExplicitType(type, availableImports, currentPkg) + GAP + name);
246 for (int i = 0; i < parameters.size(); i++) {
247 Parameter p = parameters.get(i);
248 String separator = COMMA;
249 if (i + 1 == parameters.size()) {
252 builder.append(getExplicitType(p.getType(), availableImports, currentPkg) + GAP + p.getName() + separator);
257 return builder.toString();
260 public static String createConstructor(GeneratedTransferObject genTransferObject, final String indent,
261 Map<String, LinkedHashMap<String, Integer>> availableImports, boolean isIdentity) {
262 final StringBuilder builder = new StringBuilder();
264 final String currentPkg = genTransferObject.getPackageName();
265 final List<GeneratedProperty> properties = genTransferObject.getProperties();
266 final List<GeneratedProperty> ctorParams = new ArrayList<GeneratedProperty>();
267 if (properties != null) {
268 for (final GeneratedProperty property : properties) {
269 if (property.isReadOnly()) {
270 ctorParams.add(property);
275 builder.append(indent);
276 builder.append(isIdentity ? PROTECTED : PUBLIC);
278 builder.append(genTransferObject.getName());
281 if (!ctorParams.isEmpty()) {
282 builder.append(getExplicitType(ctorParams.get(0).getReturnType(), availableImports, currentPkg));
284 builder.append(ctorParams.get(0).getName());
285 for (int i = 1; i < ctorParams.size(); ++i) {
286 final GeneratedProperty param = ctorParams.get(i);
287 builder.append(", ");
288 builder.append(getExplicitType(param.getReturnType(), availableImports, currentPkg));
290 builder.append(param.getName());
293 builder.append(RB + GAP + LCB + NL + indent + TAB + "super();" + NL);
294 if (!ctorParams.isEmpty()) {
295 for (final GeneratedProperty property : ctorParams) {
296 builder.append(indent);
298 builder.append("this.");
299 builder.append(property.getName());
300 builder.append(" = ");
301 builder.append(property.getName());
306 List<Constant> consts = genTransferObject.getConstantDefinitions();
307 for (Constant con : consts) {
308 if (con.getName() == null || con.getType() == null || con.getValue() == null)
310 if (con.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) {
311 Object values = con.getValue();
312 if (values instanceof List) {
313 for (Object regEx : (List<?>) values) {
314 if (regEx instanceof String) {
315 builder.append(indent + TAB + "for (String regEx : " + TypeConstants.PATTERN_CONSTANT_NAME
317 builder.append(indent + TAB + TAB + "this." + MEMBER_PATTERN_LIST
318 + ".add(Pattern.compile(regEx))" + SC + NL);
319 builder.append(indent + TAB + RCB + NL);
330 builder.append(indent);
332 return builder.toString();
335 public static String createGetter(final GeneratedProperty property, final String indent,
336 Map<String, LinkedHashMap<String, Integer>> availableImports, final String currentPkg) {
337 final StringBuilder builder = new StringBuilder();
339 final Type type = property.getReturnType();
340 final String varName = property.getName();
341 final char first = Character.toUpperCase(varName.charAt(0));
342 final String methodName = "get" + first + varName.substring(1);
344 builder.append(indent + PUBLIC + GAP + getExplicitType(type, availableImports, currentPkg) + GAP + methodName);
345 builder.append(LB + RB + LCB + NL);
347 String currentIndent = indent + TAB;
349 builder.append(currentIndent + "return " + varName + SC + NL);
351 builder.append(indent + RCB);
352 return builder.toString();
355 public static String createSetter(final GeneratedProperty property, final String indent,
356 Map<String, LinkedHashMap<String, Integer>> availableImports, String currentPkg) {
357 final StringBuilder builder = new StringBuilder();
359 final Type type = property.getReturnType();
360 final String varName = property.getName();
361 final char first = Character.toUpperCase(varName.charAt(0));
362 final String methodName = "set" + first + varName.substring(1);
364 builder.append(indent + PUBLIC + GAP + "void" + GAP + methodName);
365 builder.append(LB + getExplicitType(type, availableImports, currentPkg) + GAP + varName + RB + LCB + NL);
366 String currentIndent = indent + TAB;
367 builder.append(currentIndent + "this." + varName + " = " + varName + SC + NL);
368 builder.append(indent + RCB);
369 return builder.toString();
372 public static String createHashCode(final List<GeneratedProperty> properties, final String indent) {
373 StringBuilder builder = new StringBuilder();
374 builder.append(indent + "public int hashCode() {" + NL);
375 builder.append(indent + TAB + "final int prime = 31;" + NL);
376 builder.append(indent + TAB + "int result = 1;" + NL);
378 for (GeneratedProperty property : properties) {
379 String fieldName = property.getName();
380 builder.append(indent + TAB + "result = prime * result + ((" + fieldName + " == null) ? 0 : " + fieldName
381 + ".hashCode());" + NL);
384 builder.append(indent + TAB + "return result;" + NL);
385 builder.append(indent + RCB + NL);
386 return builder.toString();
389 public static String createEquals(final GeneratedTransferObject type, final List<GeneratedProperty> properties,
390 final String indent) {
391 StringBuilder builder = new StringBuilder();
392 final String indent1 = indent + TAB;
393 final String indent2 = indent1 + TAB;
394 final String indent3 = indent2 + TAB;
396 builder.append(indent + "public boolean equals(Object obj) {" + NL);
397 builder.append(indent1 + "if (this == obj) {" + NL);
398 builder.append(indent2 + "return true;" + NL);
399 builder.append(indent1 + "}" + NL);
400 builder.append(indent1 + "if (obj == null) {" + NL);
401 builder.append(indent2 + "return false;" + NL);
402 builder.append(indent1 + "}" + NL);
403 builder.append(indent1 + "if (getClass() != obj.getClass()) {" + NL);
404 builder.append(indent2 + "return false;" + NL);
405 builder.append(indent1 + "}" + NL);
407 String typeStr = type.getName();
408 builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;" + NL);
410 for (GeneratedProperty property : properties) {
411 String fieldName = property.getName();
412 builder.append(indent1 + "if (" + fieldName + " == null) {" + NL);
413 builder.append(indent2 + "if (other." + fieldName + " != null) {" + NL);
414 builder.append(indent3 + "return false;" + NL);
415 builder.append(indent2 + "}" + NL);
416 builder.append(indent1 + "} else if (!" + fieldName + ".equals(other." + fieldName + ")) {" + NL);
417 builder.append(indent2 + "return false;" + NL);
418 builder.append(indent1 + "}" + NL);
421 builder.append(indent1 + "return true;" + NL);
423 builder.append(indent + RCB + NL);
424 return builder.toString();
427 public static String createToString(final GeneratedTransferObject type, final List<GeneratedProperty> properties,
428 final String indent) {
429 StringBuilder builder = new StringBuilder();
430 builder.append(indent);
431 builder.append("public String toString() {");
433 builder.append(indent);
435 builder.append("StringBuilder builder = new StringBuilder();");
437 builder.append(indent);
439 builder.append("builder.append(\"");
440 builder.append(type.getName());
441 builder.append(" [");
443 boolean first = true;
444 for (GeneratedProperty property : properties) {
446 builder.append(property.getName());
447 builder.append("=\");");
449 builder.append(indent);
451 builder.append("builder.append(");
452 builder.append(property.getName());
453 builder.append(");");
457 builder.append(indent);
459 builder.append("builder.append(\", ");
460 builder.append(property.getName());
461 builder.append("=\");");
463 builder.append(indent);
465 builder.append("builder.append(");
466 builder.append(property.getName());
467 builder.append(");");
471 builder.append(indent);
473 builder.append("builder.append(\"]\");");
475 builder.append(indent);
477 builder.append("return builder.toString();");
480 builder.append(indent);
483 return builder.toString();
486 public static String createEnum(final Enumeration enumeration, final String indent) {
487 if (enumeration == null || indent == null)
488 throw new IllegalArgumentException();
489 final StringBuilder builder = new StringBuilder(indent + PUBLIC + GAP + ENUM + GAP + enumeration.getName()
492 String separator = COMMA + NL;
493 final List<Pair> values = enumeration.getValues();
495 for (int i = 0; i < values.size(); i++) {
496 if (i + 1 == values.size()) {
499 builder.append(indent + TAB + values.get(i).getName() + LB + values.get(i).getValue() + RB + separator);
503 final String ENUMERATION_NAME = "value";
504 final String ENUMERATION_TYPE = "int";
505 builder.append(indent + TAB + ENUMERATION_TYPE + GAP + ENUMERATION_NAME + SC);
507 builder.append(indent + TAB + PRIVATE + GAP + enumeration.getName() + LB + ENUMERATION_TYPE + GAP
508 + ENUMERATION_NAME + RB + GAP + LCB + NL);
509 builder.append(indent + TAB + TAB + "this." + ENUMERATION_NAME + GAP + "=" + GAP + ENUMERATION_NAME + SC + NL);
510 builder.append(indent + TAB + RCB + NL);
512 builder.append(indent + RCB);
514 return builder.toString();
517 private static String getExplicitType(final Type type,
518 Map<String, LinkedHashMap<String, Integer>> availableImports, final String currentPkg) {
520 throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!");
522 String packageName = type.getPackageName();
524 LinkedHashMap<String, Integer> imports = availableImports.get(type.getName());
526 if ((imports != null && packageName.equals(findMaxValue(imports).get(0))) || packageName.equals(currentPkg)) {
527 final StringBuilder builder = new StringBuilder(type.getName());
528 if (type instanceof ParameterizedType) {
529 ParameterizedType pType = (ParameterizedType) type;
530 Type[] pTypes = pType.getActualTypeArguments();
532 builder.append(getParameters(pTypes, availableImports, currentPkg));
535 if (builder.toString().equals("Void")) {
538 return builder.toString();
540 final StringBuilder builder = new StringBuilder();
541 if (packageName.startsWith("java.lang")) {
542 builder.append(type.getName());
544 if (!packageName.isEmpty()) {
545 builder.append(packageName + "." + type.getName());
547 builder.append(type.getName());
551 if (type instanceof ParameterizedType) {
552 ParameterizedType pType = (ParameterizedType) type;
553 Type[] pTypes = pType.getActualTypeArguments();
555 builder.append(getParameters(pTypes, availableImports, currentPkg));
558 if (builder.toString().equals("Void")) {
561 return builder.toString();
565 private static String getParameters(final Type[] pTypes,
566 Map<String, LinkedHashMap<String, Integer>> availableImports, String currentPkg) {
567 final StringBuilder builder = new StringBuilder();
568 for (int i = 0; i < pTypes.length; i++) {
571 String separator = COMMA;
572 if (i + 1 == pTypes.length) {
576 String wildcardParam = "";
577 if (t instanceof WildcardType) {
578 wildcardParam = "? extends ";
581 builder.append(wildcardParam + getExplicitType(t, availableImports, currentPkg) + separator);
583 return builder.toString();
586 private static List<String> findMaxValue(LinkedHashMap<String, Integer> imports) {
587 final List<String> result = new ArrayList<String>();
590 int currentValue = 0;
591 for (Map.Entry<String, Integer> entry : imports.entrySet()) {
592 currentValue = entry.getValue();
593 if (currentValue > maxValue) {
595 result.add(entry.getKey());
596 maxValue = currentValue;
597 } else if (currentValue == maxValue) {
598 result.add(entry.getKey());
604 private static void createComment(final StringBuilder builder, final String comment, final String indent) {
605 if (comment != null && comment.length() > 0) {
606 builder.append(indent + "/*" + NL);
607 builder.append(indent + comment + NL);
608 builder.append(indent + "*/" + NL);
612 public static Map<String, LinkedHashMap<String, Integer>> createImports(GeneratedType genType) {
613 final Map<String, LinkedHashMap<String, Integer>> imports = new HashMap<String, LinkedHashMap<String, Integer>>();
614 final String genTypePkg = genType.getPackageName();
616 final List<Constant> constants = genType.getConstantDefinitions();
617 final List<MethodSignature> methods = genType.getMethodDefinitions();
618 List<Type> impl = genType.getImplements();
622 for (Type t : impl) {
623 addTypeToImports(t, imports, genTypePkg);
628 if (constants != null) {
629 for (Constant c : constants) {
630 Type ct = c.getType();
631 addTypeToImports(ct, imports, genTypePkg);
636 if (methods != null) {
637 for (MethodSignature m : methods) {
638 Type ct = m.getReturnType();
639 addTypeToImports(ct, imports, genTypePkg);
640 for (MethodSignature.Parameter p : m.getParameters()) {
641 addTypeToImports(p.getType(), imports, genTypePkg);
647 if (genType instanceof GeneratedTransferObject) {
648 GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
650 List<GeneratedProperty> props = genTO.getProperties();
652 for (GeneratedProperty prop : props) {
653 Type pt = prop.getReturnType();
654 addTypeToImports(pt, imports, genTypePkg);
659 // REGULAR EXPRESSION
660 if (genType instanceof GeneratedTransferObject) {
661 if (isConstantInTO(TypeConstants.PATTERN_CONSTANT_NAME, (GeneratedTransferObject) genType)) {
662 addTypeToImports(Types.typeForClass(java.util.regex.Pattern.class), imports, genTypePkg);
663 addTypeToImports(Types.typeForClass(java.util.Arrays.class), imports, genTypePkg);
664 addTypeToImports(Types.typeForClass(java.util.ArrayList.class), imports, genTypePkg);
671 private static void addTypeToImports(Type type, Map<String, LinkedHashMap<String, Integer>> importedTypes,
673 String typeName = type.getName();
674 String typePkg = type.getPackageName();
675 if (typePkg.startsWith("java.lang") || typePkg.equals(genTypePkg) || typePkg.isEmpty()) {
678 LinkedHashMap<String, Integer> packages = importedTypes.get(typeName);
679 if (packages == null) {
680 packages = new LinkedHashMap<String, Integer>();
681 packages.put(typePkg, 1);
682 importedTypes.put(typeName, packages);
684 Integer occurrence = packages.get(typePkg);
685 if (occurrence == null) {
686 packages.put(typePkg, 1);
689 packages.put(typePkg, occurrence);
693 if (type instanceof ParameterizedType) {
694 ParameterizedType pt = (ParameterizedType) type;
695 Type[] params = pt.getActualTypeArguments();
696 for (Type param : params) {
697 addTypeToImports(param, importedTypes, genTypePkg);
702 public static List<String> createImportLines(Map<String, LinkedHashMap<String, Integer>> imports) {
703 List<String> importLines = new ArrayList<String>();
705 for (Map.Entry<String, LinkedHashMap<String, Integer>> entry : imports.entrySet()) {
706 String typeName = entry.getKey();
707 LinkedHashMap<String, Integer> typePkgMap = entry.getValue();
708 String typePkg = typePkgMap.keySet().iterator().next();
709 importLines.add("import " + typePkg + "." + typeName + SC);
714 public static boolean isConstantInTO(String constName, GeneratedTransferObject genTO) {
715 if (constName == null || genTO == null)
716 throw new IllegalArgumentException();
717 List<Constant> consts = genTO.getConstantDefinitions();
718 for (Constant cons : consts) {
719 if (cons.getName().equals(constName)) {