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.Iterator;
14 import java.util.LinkedHashMap;
15 import java.util.List;
18 import org.opendaylight.controller.binding.generator.util.TypeConstants;
19 import org.opendaylight.controller.sal.binding.model.api.*;
20 import org.opendaylight.controller.sal.binding.model.api.Enumeration.Pair;
21 import org.opendaylight.controller.sal.binding.model.api.MethodSignature.Parameter;
22 import org.opendaylight.controller.binding.generator.util.Types;
24 public final class GeneratorUtil {
26 private GeneratorUtil() {
29 public static String createIfcDeclaration(final GeneratedType genType, final String indent,
30 final Map<String, String> availableImports) {
31 return createFileDeclaration(IFC, genType, indent, availableImports, false, false);
34 public static String createClassDeclaration(final GeneratedTransferObject genTransferObject, final String indent,
35 final Map<String, String> availableImports, boolean isIdentity, boolean isInnerClass) {
36 return createFileDeclaration(CLASS, genTransferObject, indent, availableImports, isIdentity, isInnerClass);
39 public static String createPackageDeclaration(final String packageName) {
40 return PKG + GAP + packageName + SC;
43 private static String createFileDeclaration(final String type, final GeneratedType genType, final String indent,
44 final Map<String, String> availableImports, boolean isIdentity, boolean innerClass) {
45 final StringBuilder builder = new StringBuilder();
46 final String currentPkg = genType.getPackageName();
48 createComment(builder, genType.getComment(), indent);
50 if (!genType.getAnnotations().isEmpty()) {
51 final List<AnnotationType> annotations = genType.getAnnotations();
52 appendAnnotations(builder, annotations);
57 builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP + type + GAP + genType.getName() + GAP);
58 } else if (isIdentity) {
59 if (!(CLASS.equals(type))) {
60 throw new IllegalArgumentException("'identity' has to be generated as a class");
62 builder.append(indent + PUBLIC + GAP + ABSTRACT + GAP + type + GAP + genType.getName() + GAP);
64 builder.append(indent + PUBLIC + GAP + type + GAP + genType.getName() + GAP);
67 if (genType instanceof GeneratedTransferObject) {
68 GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
70 if (genTO.getExtends() != null) {
71 builder.append(EXTENDS + GAP);
72 String gtoString = getExplicitType(genTO.getExtends(), availableImports, currentPkg);
73 builder.append(gtoString + GAP);
77 final List<Type> genImplements = genType.getImplements();
78 if (!genImplements.isEmpty()) {
79 if (genType instanceof GeneratedTransferObject) {
80 builder.append(IMPLEMENTS + GAP);
82 builder.append(EXTENDS + GAP);
84 builder.append(getExplicitType(genImplements.get(0), availableImports, currentPkg));
86 for (int i = 1; i < genImplements.size(); ++i) {
88 builder.append(getExplicitType(genImplements.get(i), availableImports, currentPkg));
91 builder.append(GAP + LCB);
92 return builder.toString();
95 private static StringBuilder appendAnnotations(final StringBuilder builder, final List<AnnotationType> annotations) {
96 if ((builder != null) && (annotations != null)) {
97 for (final AnnotationType annotation : annotations) {
99 builder.append(annotation.getPackageName());
101 builder.append(annotation.getName());
103 if (annotation.containsParameters()) {
105 final List<AnnotationType.Parameter> parameters = annotation.getParameters();
106 appendAnnotationParams(builder, parameters);
114 private static StringBuilder appendAnnotationParams(final StringBuilder builder,
115 final List<AnnotationType.Parameter> parameters) {
116 if (parameters != null) {
118 for (final AnnotationType.Parameter param : parameters) {
123 builder.append(", ");
125 final String paramName = param.getName();
126 if (param.getValue() != null) {
127 builder.append(paramName);
128 builder.append(" = ");
129 builder.append(param.getValue());
131 builder.append(paramName);
132 builder.append(" = {");
133 final List<String> values = param.getValues();
134 builder.append(values.get(0));
135 for (int j = 1; j < values.size(); ++j) {
136 builder.append(", ");
137 builder.append(values.get(j));
147 public static String createConstant(final Constant constant, final String indent,
148 final Map<String, String> availableImports, final String currentPkg) {
149 final StringBuilder builder = new StringBuilder();
150 if (constant == null)
151 throw new IllegalArgumentException();
152 builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP);
153 builder.append(getExplicitType(constant.getType(), availableImports, currentPkg) + GAP + constant.getName());
154 builder.append(GAP + "=" + GAP);
156 if (constant.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) {
159 builder.append(constant.getValue());
163 return builder.toString();
166 public static String createField(final GeneratedProperty property, final String indent,
167 final Map<String, String> availableImports, final String currentPkg) {
168 final StringBuilder builder = new StringBuilder();
169 if (!property.getAnnotations().isEmpty()) {
170 final List<AnnotationType> annotations = property.getAnnotations();
171 appendAnnotations(builder, annotations);
174 builder.append(indent + PRIVATE + GAP);
175 builder.append(getExplicitType(property.getReturnType(), availableImports, currentPkg) + GAP
176 + property.getName());
178 return builder.toString();
182 * Create method declaration in interface.
188 public static String createMethodDeclaration(final MethodSignature method, final String indent,
189 Map<String, String> availableImports, final String currentPkg) {
190 final StringBuilder builder = new StringBuilder();
192 if (method == null) {
193 throw new IllegalArgumentException("Method Signature parameter MUST be specified and cannot be NULL!");
196 final String comment = method.getComment();
197 final String name = method.getName();
199 throw new IllegalStateException("Method Name cannot be NULL!");
202 final Type type = method.getReturnType();
204 throw new IllegalStateException("Method Return type cannot be NULL!");
207 final List<Parameter> parameters = method.getParameters();
209 createComment(builder, comment, indent);
212 if (!method.getAnnotations().isEmpty()) {
213 builder.append(indent);
214 final List<AnnotationType> annotations = method.getAnnotations();
215 appendAnnotations(builder, annotations);
219 builder.append(indent + getExplicitType(type, availableImports, currentPkg) + GAP + name);
221 for (int i = 0; i < parameters.size(); i++) {
222 Parameter p = parameters.get(i);
223 String separator = COMMA;
224 if (i + 1 == parameters.size()) {
227 builder.append(getExplicitType(p.getType(), availableImports, currentPkg) + GAP + p.getName() + separator);
232 return builder.toString();
235 public static String createConstructor(GeneratedTransferObject genTransferObject, final String indent,
236 final Map<String, String> availableImports, boolean isIdentity) {
237 StringBuilder builder = new StringBuilder();
239 final String currentPkg = genTransferObject.getPackageName();
240 final List<GeneratedProperty> properties = genTransferObject.getProperties();
241 final List<GeneratedProperty> ctorParams = new ArrayList<GeneratedProperty>();
242 if (properties != null) {
243 for (final GeneratedProperty property : properties) {
244 if (property.isReadOnly()) {
245 ctorParams.add(property);
250 builder.append(createConstructorDeclarationToLeftParenthesis(genTransferObject, indent, isIdentity));
252 final String parameterSeparator = COMMA + GAP;
253 for (final GeneratedProperty ctorParam : ctorParams) {
254 builder.append(createMethodParamDeclaration(ctorParam, availableImports, currentPkg));
255 builder.append(parameterSeparator);
257 if (!ctorParams.isEmpty()) {
258 builder = builder.delete(builder.length() - parameterSeparator.length(), builder.length());
260 builder.append(createConstructorDeclarationFromRightParenthesis());
261 builder.append(createConstructorSuperCalling(indent));
263 for (final GeneratedProperty ctorParam : ctorParams) {
264 builder.append(createClassAttributeInitialization(indent, ctorParam));
267 builder.append(createConstructorClosingPart(indent));
268 return builder.toString();
271 public static String createConstructors(GeneratedTransferObject genTransferObject, final String indent,
272 final Map<String, String> availableImports, boolean isIdentity) {
273 final StringBuilder builder = new StringBuilder();
275 final String currentPkg = genTransferObject.getPackageName();
276 final List<GeneratedProperty> properties = genTransferObject.getProperties();
277 final List<GeneratedProperty> ctorParams = new ArrayList<GeneratedProperty>();
278 if (properties != null) {
279 for (final GeneratedProperty property : properties) {
280 if (property.isReadOnly()) {
281 ctorParams.add(property);
286 GeneratedProperty ctorParam;
287 Iterator<GeneratedProperty> iteratorCtorParams = ctorParams.iterator();
291 if (iteratorCtorParams.hasNext()) {
292 ctorParam = iteratorCtorParams.next();
294 builder.append(createConstructorDeclarationToLeftParenthesis(genTransferObject, indent, isIdentity));
296 if (ctorParam != null) {
297 builder.append(createMethodParamDeclaration(ctorParam, availableImports, currentPkg));
299 builder.append(createConstructorDeclarationFromRightParenthesis());
300 builder.append(createConstructorSuperCalling(indent));
302 if (ctorParam != null) {
303 builder.append(createClassAttributeInitialization(indent, ctorParam));
306 builder.append(createConstructorClosingPart(indent));
307 } while (iteratorCtorParams.hasNext());
309 return builder.toString();
312 private static String createConstructorDeclarationToLeftParenthesis(GeneratedTransferObject genTransferObject,
313 final String indent, boolean isIdentity) {
314 final StringBuilder builder = new StringBuilder();
315 builder.append(indent);
316 builder.append(isIdentity ? PROTECTED : PUBLIC);
318 builder.append(genTransferObject.getName());
320 return builder.toString();
323 private static String createConstructorDeclarationFromRightParenthesis() {
324 final StringBuilder builder = new StringBuilder();
325 builder.append(RB + GAP + LCB + NL);
326 return builder.toString();
329 private static String createConstructorSuperCalling(String indent) {
330 final StringBuilder builder = new StringBuilder();
331 builder.append(indent + TAB + "super();" + NL);
332 return builder.toString();
335 private static String createConstructorClosingPart(String indent) {
336 final StringBuilder builder = new StringBuilder();
337 builder.append(indent);
339 builder.append(NL + NL);
340 return builder.toString();
343 private static String createClassAttributeInitialization(String indent, GeneratedProperty methodParameter) {
344 final StringBuilder builder = new StringBuilder();
345 builder.append(indent);
347 builder.append("this.");
348 builder.append(methodParameter.getName());
349 builder.append(" = ");
350 builder.append(methodParameter.getName());
353 return builder.toString();
356 private static String createMethodParamDeclaration(GeneratedProperty methodParameter,
357 final Map<String, String> availableImports, String currentPkg) {
358 final StringBuilder builder = new StringBuilder();
359 builder.append(getExplicitType(methodParameter.getReturnType(), availableImports, currentPkg));
361 builder.append(methodParameter.getName());
362 return builder.toString();
365 public static String createGetter(final GeneratedProperty property, final String indent,
366 final Map<String, String> availableImports, final String currentPkg) {
367 final StringBuilder builder = new StringBuilder();
369 final Type type = property.getReturnType();
370 final String varName = property.getName();
371 final char first = Character.toUpperCase(varName.charAt(0));
372 final String methodName = "get" + first + varName.substring(1);
374 builder.append(indent + PUBLIC + GAP + getExplicitType(type, availableImports, currentPkg) + GAP + methodName);
375 builder.append(LB + RB + LCB + NL);
377 String currentIndent = indent + TAB;
379 builder.append(currentIndent + "return " + varName + SC + NL);
381 builder.append(indent + RCB);
382 return builder.toString();
385 public static String createSetter(final GeneratedProperty property, final String indent,
386 final Map<String, String> availableImports, final String currentPkg) {
387 final StringBuilder builder = new StringBuilder();
389 final Type type = property.getReturnType();
390 final String varName = property.getName();
391 final char first = Character.toUpperCase(varName.charAt(0));
392 final String methodName = "set" + first + varName.substring(1);
394 builder.append(indent + PUBLIC + GAP + "void" + GAP + methodName);
395 builder.append(LB + getExplicitType(type, availableImports, currentPkg) + GAP + varName + RB + LCB + NL);
396 String currentIndent = indent + TAB;
397 builder.append(currentIndent + "this." + varName + " = " + varName + SC + NL);
398 builder.append(indent + RCB);
399 return builder.toString();
402 public static String createHashCode(final List<GeneratedProperty> properties, final String indent) {
403 StringBuilder builder = new StringBuilder();
404 builder.append(indent + "public int hashCode() {" + NL);
405 builder.append(indent + TAB + "final int prime = 31;" + NL);
406 builder.append(indent + TAB + "int result = 1;" + NL);
408 for (GeneratedProperty property : properties) {
409 String fieldName = property.getName();
410 builder.append(indent + TAB + "result = prime * result + ((" + fieldName + " == null) ? 0 : " + fieldName
411 + ".hashCode());" + NL);
414 builder.append(indent + TAB + "return result;" + NL);
415 builder.append(indent + RCB + NL);
416 return builder.toString();
419 public static String createEquals(final GeneratedTransferObject type, final List<GeneratedProperty> properties,
420 final String indent) {
421 final StringBuilder builder = new StringBuilder();
422 final String indent1 = indent + TAB;
423 final String indent2 = indent1 + TAB;
424 final String indent3 = indent2 + TAB;
426 builder.append(indent + "public boolean equals(Object obj) {" + NL);
427 builder.append(indent1 + "if (this == obj) {" + NL);
428 builder.append(indent2 + "return true;" + NL);
429 builder.append(indent1 + "}" + NL);
430 builder.append(indent1 + "if (obj == null) {" + NL);
431 builder.append(indent2 + "return false;" + NL);
432 builder.append(indent1 + "}" + NL);
433 builder.append(indent1 + "if (getClass() != obj.getClass()) {" + NL);
434 builder.append(indent2 + "return false;" + NL);
435 builder.append(indent1 + "}" + NL);
437 String typeStr = type.getName();
438 builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;" + NL);
440 for (final GeneratedProperty property : properties) {
441 String fieldName = property.getName();
442 builder.append(indent1 + "if (" + fieldName + " == null) {" + NL);
443 builder.append(indent2 + "if (other." + fieldName + " != null) {" + NL);
444 builder.append(indent3 + "return false;" + NL);
445 builder.append(indent2 + "}" + NL);
446 builder.append(indent1 + "} else if (!" + fieldName + ".equals(other." + fieldName + ")) {" + NL);
447 builder.append(indent2 + "return false;" + NL);
448 builder.append(indent1 + "}" + NL);
451 builder.append(indent1 + "return true;" + NL);
452 builder.append(indent + RCB + NL);
453 return builder.toString();
456 public static String createToString(final GeneratedTransferObject type, final List<GeneratedProperty> properties,
457 final String indent) {
458 StringBuilder builder = new StringBuilder();
459 builder.append(indent);
460 builder.append("public String toString() {");
462 builder.append(indent);
464 builder.append("StringBuilder builder = new StringBuilder();");
466 builder.append(indent);
468 builder.append("builder.append(\"");
469 builder.append(type.getName());
470 builder.append(" [");
472 boolean first = true;
473 for (final GeneratedProperty property : properties) {
475 builder.append(property.getName());
476 builder.append("=\");");
478 builder.append(indent);
480 builder.append("builder.append(");
481 builder.append(property.getName());
482 builder.append(");");
486 builder.append(indent);
488 builder.append("builder.append(\", ");
489 builder.append(property.getName());
490 builder.append("=\");");
492 builder.append(indent);
494 builder.append("builder.append(");
495 builder.append(property.getName());
496 builder.append(");");
500 builder.append(indent);
502 builder.append("builder.append(\"]\");");
504 builder.append(indent);
506 builder.append("return builder.toString();");
509 builder.append(indent);
512 return builder.toString();
515 public static String createEnum(final Enumeration enumeration, final String indent) {
516 if (enumeration == null || indent == null)
517 throw new IllegalArgumentException();
518 final StringBuilder builder = new StringBuilder(indent + PUBLIC + GAP + ENUM + GAP + enumeration.getName()
521 String separator = COMMA + NL;
522 final List<Pair> values = enumeration.getValues();
524 for (int i = 0; i < values.size(); i++) {
525 if (i + 1 == values.size()) {
528 builder.append(indent + TAB + values.get(i).getName() + LB + values.get(i).getValue() + RB + separator);
532 final String ENUMERATION_NAME = "value";
533 final String ENUMERATION_TYPE = "int";
534 builder.append(indent + TAB + ENUMERATION_TYPE + GAP + ENUMERATION_NAME + SC);
536 builder.append(indent + TAB + PRIVATE + GAP + enumeration.getName() + LB + ENUMERATION_TYPE + GAP
537 + ENUMERATION_NAME + RB + GAP + LCB + NL);
538 builder.append(indent + TAB + TAB + "this." + ENUMERATION_NAME + GAP + "=" + GAP + ENUMERATION_NAME + SC + NL);
539 builder.append(indent + TAB + RCB + NL);
541 builder.append(indent + RCB);
543 return builder.toString();
546 private static String getExplicitType(final Type type, final Map<String, String> imports, final String currentPkg) {
548 throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!");
550 if (type.getName() == null) {
551 throw new IllegalArgumentException("Type name cannot be NULL!");
553 if (type.getPackageName() == null) {
554 throw new IllegalArgumentException("Type cannot have Package Name referenced as NULL!");
556 if (imports == null) {
557 throw new IllegalArgumentException("Imports Map cannot be NULL!");
560 final String typePackageName = type.getPackageName();
561 final String typeName = type.getName();
562 final String importedPackageName = imports.get(typeName);
563 if (typePackageName.equals(importedPackageName) || typePackageName.equals(currentPkg)) {
564 final StringBuilder builder = new StringBuilder(type.getName());
565 if (type instanceof ParameterizedType) {
566 final ParameterizedType pType = (ParameterizedType) type;
567 final Type[] pTypes = pType.getActualTypeArguments();
569 builder.append(getParameters(pTypes, imports, currentPkg));
572 if (builder.toString().equals("Void")) {
575 return builder.toString();
577 final StringBuilder builder = new StringBuilder();
578 if (typePackageName.startsWith("java.lang")) {
579 builder.append(type.getName());
581 if (!typePackageName.isEmpty()) {
582 builder.append(typePackageName + "." + type.getName());
584 builder.append(type.getName());
587 if (type.equals(Types.voidType())) {
590 if (type instanceof ParameterizedType) {
591 final ParameterizedType pType = (ParameterizedType) type;
592 final Type[] pTypes = pType.getActualTypeArguments();
594 builder.append(getParameters(pTypes, imports, currentPkg));
597 return builder.toString();
601 private static String getParameters(final Type[] pTypes, Map<String, String> availableImports, String currentPkg) {
602 final StringBuilder builder = new StringBuilder();
603 for (int i = 0; i < pTypes.length; i++) {
604 final Type t = pTypes[i];
606 String separator = COMMA;
607 if (i == (pTypes.length - 1)) {
611 String wildcardParam = "";
612 if (t.equals(Types.voidType())) {
613 builder.append("java.lang.Void" + separator);
617 if (t instanceof WildcardType) {
618 wildcardParam = "? extends ";
621 builder.append(wildcardParam + getExplicitType(t, availableImports, currentPkg) + separator);
624 return builder.toString();
627 private static void createComment(final StringBuilder builder, final String comment, final String indent) {
628 if (comment != null && comment.length() > 0) {
629 builder.append(indent + "/*" + NL);
630 builder.append(indent + comment + NL);
631 builder.append(indent + "*/" + NL);
635 public static Map<String, String> createImports(GeneratedType genType) {
636 if (genType == null) {
637 throw new IllegalArgumentException("Generated Type cannot be NULL!");
639 final Map<String, String> imports = new LinkedHashMap<>();
640 List<GeneratedType> childGeneratedTypes = genType.getEnclosedTypes();
641 if (!childGeneratedTypes.isEmpty()) {
642 for (GeneratedType genTypeChild : childGeneratedTypes) {
643 imports.putAll(createImports(genTypeChild));
647 final List<Constant> constants = genType.getConstantDefinitions();
648 final List<MethodSignature> methods = genType.getMethodDefinitions();
649 final List<Type> impl = genType.getImplements();
653 for (final Type type : impl) {
654 putTypeIntoImports(genType, type, imports);
659 if (constants != null) {
660 for (final Constant constant : constants) {
661 final Type constantType = constant.getType();
662 putTypeIntoImports(genType, constantType, imports);
666 // REGULAR EXPRESSION
667 if (genType instanceof GeneratedTransferObject) {
668 if (isConstantInTO(TypeConstants.PATTERN_CONSTANT_NAME, (GeneratedTransferObject) genType)) {
669 putTypeIntoImports(genType, Types.typeForClass(java.util.regex.Pattern.class), imports);
670 putTypeIntoImports(genType, Types.typeForClass(java.util.Arrays.class), imports);
671 putTypeIntoImports(genType, Types.typeForClass(java.util.ArrayList.class), imports);
676 if (methods != null) {
677 for (final MethodSignature method : methods) {
678 final Type methodReturnType = method.getReturnType();
679 putTypeIntoImports(genType, methodReturnType, imports);
680 for (final MethodSignature.Parameter methodParam : method.getParameters()) {
681 putTypeIntoImports(genType, methodParam.getType(), imports);
687 if (genType instanceof GeneratedTransferObject) {
688 final GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
689 final List<GeneratedProperty> properties = genTO.getProperties();
690 if (properties != null) {
691 for (GeneratedProperty property : properties) {
692 final Type propertyType = property.getReturnType();
693 putTypeIntoImports(genType, propertyType, imports);
701 public static Map<String, String> createChildImports(GeneratedType genType) {
702 Map<String, String> childImports = new LinkedHashMap<>();
703 List<GeneratedType> childGeneratedTypes = genType.getEnclosedTypes();
704 if (!childGeneratedTypes.isEmpty()) {
705 for (GeneratedType genTypeChild : childGeneratedTypes) {
706 createChildImports(genTypeChild);
707 childImports.put(genTypeChild.getName(), genTypeChild.getPackageName());
713 private static void putTypeIntoImports(final GeneratedType parentGenType, final Type type,
714 final Map<String, String> imports) {
715 if (parentGenType == null) {
716 throw new IllegalArgumentException("Parent Generated Type parameter MUST be specified and cannot be "
719 if (parentGenType.getName() == null) {
720 throw new IllegalArgumentException("Parent Generated Type name cannot be NULL!");
722 if (parentGenType.getPackageName() == null) {
723 throw new IllegalArgumentException("Parent Generated Type cannot have Package Name referenced as NULL!");
726 throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!");
728 if (type.getName() == null) {
729 throw new IllegalArgumentException("Type name cannot be NULL!");
731 if (type.getPackageName() == null) {
732 throw new IllegalArgumentException("Type cannot have Package Name referenced as NULL!");
735 final String typeName = type.getName();
736 final String typePackageName = type.getPackageName();
737 final String parentTypeName = parentGenType.getName();
738 final String parentTypePackageName = parentGenType.getPackageName();
739 if (typeName.equals(parentTypeName) || typePackageName.startsWith("java.lang")
740 || typePackageName.equals(parentTypePackageName) || typePackageName.isEmpty()) {
743 if (!imports.containsKey(typeName)) {
744 imports.put(typeName, typePackageName);
746 if (type instanceof ParameterizedType) {
747 final ParameterizedType paramType = (ParameterizedType) type;
748 final Type[] params = paramType.getActualTypeArguments();
749 for (Type param : params) {
750 putTypeIntoImports(parentGenType, param, imports);
755 public static List<String> createImportLines(final Map<String, String> imports,
756 final Map<String, String> innerTypeImports) {
757 final List<String> importLines = new ArrayList<>();
759 for (Map.Entry<String, String> entry : imports.entrySet()) {
760 final String typeName = entry.getKey();
761 final String packageName = entry.getValue();
762 if (innerTypeImports != null) {
763 String innerTypePackageName = innerTypeImports.get(typeName);
764 if (innerTypePackageName != null) {
765 if (innerTypePackageName.equals(packageName))
769 importLines.add("import " + packageName + "." + typeName + SC);
774 public static boolean isConstantInTO(String constName, GeneratedTransferObject genTO) {
775 if (constName == null || genTO == null)
776 throw new IllegalArgumentException();
777 List<Constant> consts = genTO.getConstantDefinitions();
778 for (Constant cons : consts) {
779 if (cons.getName().equals(constName)) {
787 public static String createStaticInicializationBlock(GeneratedTransferObject genTransferObject, String indent) {
789 final StringBuilder builder = new StringBuilder();
791 List<Constant> constants = genTransferObject.getConstantDefinitions();
792 for (Constant constant : constants) {
793 if (constant.getName() == null || constant.getType() == null || constant.getValue() == null) {
796 if (constant.getName().equals(TypeConstants.PATTERN_CONSTANT_NAME)) {
797 final Object constValue = constant.getValue();
798 List<String> regularExpressions = new ArrayList<>();
799 if (constValue instanceof List) {
800 builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP + "List<String>" + GAP
801 + TypeConstants.PATTERN_CONSTANT_NAME + GAP + "=" + GAP + "Arrays.asList" + LB);
802 final List<?> constantValues = (List<?>) constValue;
803 int stringsCount = 0;
804 for (Object value : constantValues) {
805 if (value instanceof String) {
806 if (stringsCount > 0) {
807 builder.append(COMMA);
810 regularExpressions.add((String) value);
811 builder.append(DOUBLE_QUOTE + (String) value + DOUBLE_QUOTE);
814 builder.append(RB + SC + NL);
816 builder.append(indent + PRIVATE + GAP + STATIC + GAP + FINAL + GAP + "List<Pattern>" + GAP
817 + MEMBER_PATTERN_LIST + GAP + ASSIGN + GAP + "new ArrayList<Pattern>()" + GAP + SC + NL + NL);
819 if (!regularExpressions.isEmpty()) {
820 builder.append(indent + STATIC + LCB + NL);
821 builder.append(indent + TAB + "for (String regEx : " + TypeConstants.PATTERN_CONSTANT_NAME + ") {"
823 builder.append(indent + TAB + TAB + MEMBER_PATTERN_LIST + ".add(Pattern.compile(regEx))" + SC + NL);
824 builder.append(indent + TAB + RCB + NL);
825 builder.append(indent + RCB + NL + NL);
830 return builder.toString();