1 package org.opendaylight.controller.binding.generator.util;
5 import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
6 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder;
7 import org.opendaylight.controller.yang.common.QName;
8 import org.opendaylight.controller.yang.model.api.Module;
9 import org.opendaylight.controller.yang.model.api.SchemaNode;
10 import org.opendaylight.controller.yang.model.api.SchemaPath;
11 import org.opendaylight.controller.yang.model.api.TypeDefinition;
13 public final class BindingGeneratorUtil {
15 private static final String[] SET_VALUES = new String[] { "abstract", "assert", "boolean", "break", "byte", "case",
16 "catch", "char", "class", "const", "continue", "default", "double", "do", "else", "enum", "extends",
17 "false", "final", "finally", "float", "for", "goto", "if", "implements", "import", "instanceof", "int",
18 "interface", "long", "native", "new", "null", "package", "private", "protected", "public", "return",
19 "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient",
20 "true", "try", "void", "volatile", "while" };
22 private BindingGeneratorUtil() {
25 public static final Set<String> JAVA_RESERVED_WORDS = new HashSet<String>(Arrays.asList(SET_VALUES));
27 public static String validateJavaPackage(final String packageName) {
28 if (packageName != null) {
29 final String[] packNameParts = packageName.split("\\.");
30 if (packNameParts != null) {
31 final StringBuilder builder = new StringBuilder();
32 for (int i = 0; i < packNameParts.length; ++i) {
33 final String packNamePart = packNameParts[i];
34 if (Character.isDigit(packNamePart.charAt(0))) {
35 packNameParts[i] = "_" + packNamePart;
36 } else if (JAVA_RESERVED_WORDS.contains(packNamePart)) {
37 packNameParts[i] = "_" + packNamePart;
42 builder.append(packNameParts[i]);
44 return builder.toString();
50 public static String validateParameterName(final String parameterName) {
51 if (parameterName != null) {
52 if (JAVA_RESERVED_WORDS.contains(parameterName)) {
53 return "_" + parameterName;
59 public static GeneratedTOBuilder schemaNodeToTransferObjectBuilder(final String packageName,
60 final SchemaNode schemaNode, final String transObjectName) {
61 if (packageName != null && schemaNode != null && transObjectName != null) {
63 final String genTOName = BindingGeneratorUtil.parseToClassName(transObjectName);
64 final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(packageName, genTOName);
72 public static String moduleNamespaceToPackageName(final Module module) {
73 final StringBuilder packageNameBuilder = new StringBuilder();
75 final Calendar calendar = Calendar.getInstance();
76 if (module.getRevision() == null) {
77 throw new IllegalArgumentException("Module " + module.getName() + " does not specify revision date!");
79 packageNameBuilder.append("org.opendaylight.yang.gen.v");
80 packageNameBuilder.append(module.getYangVersion());
81 packageNameBuilder.append(".");
83 String namespace = module.getNamespace().toString();
84 namespace = namespace.replace("://", ".");
85 namespace = namespace.replace("/", ".");
86 namespace = namespace.replace(":", ".");
87 namespace = namespace.replace("-", ".");
88 namespace = namespace.replace("@", ".");
89 namespace = namespace.replace("$", ".");
90 namespace = namespace.replace("#", ".");
91 namespace = namespace.replace("'", ".");
92 namespace = namespace.replace("*", ".");
93 namespace = namespace.replace("+", ".");
94 namespace = namespace.replace(",", ".");
95 namespace = namespace.replace(";", ".");
96 namespace = namespace.replace("=", ".");
98 packageNameBuilder.append(namespace);
99 calendar.setTime(module.getRevision());
100 packageNameBuilder.append(".rev");
101 packageNameBuilder.append(calendar.get(Calendar.YEAR));
102 packageNameBuilder.append((calendar.get(Calendar.MONTH) + 1));
103 packageNameBuilder.append(calendar.get(Calendar.DAY_OF_MONTH));
105 return validateJavaPackage(packageNameBuilder.toString());
108 public static String packageNameForGeneratedType(final String basePackageName, final SchemaPath schemaPath) {
109 if (basePackageName == null) {
110 throw new IllegalArgumentException("Base Package Name cannot be NULL!");
112 if (schemaPath == null) {
113 throw new IllegalArgumentException("Schema Path cannot be NULL!");
116 final StringBuilder builder = new StringBuilder();
117 builder.append(basePackageName);
118 final List<QName> pathToNode = schemaPath.getPath();
119 final int traversalSteps = (pathToNode.size() - 1);
120 for (int i = 0; i < traversalSteps; ++i) {
122 String nodeLocalName = pathToNode.get(i).getLocalName();
124 nodeLocalName = nodeLocalName.replace(":", ".");
125 nodeLocalName = nodeLocalName.replace("-", ".");
126 builder.append(nodeLocalName);
128 return validateJavaPackage(builder.toString());
131 public static String packageNameForTypeDefinition(final String basePackageName,
132 final TypeDefinition<?> typeDefinition) {
133 if (basePackageName == null) {
134 throw new IllegalArgumentException("Base Package Name cannot be NULL!");
136 if (typeDefinition == null) {
137 throw new IllegalArgumentException("Type Definition reference cannot be NULL!");
140 final StringBuilder builder = new StringBuilder();
141 builder.append(basePackageName);
142 return validateJavaPackage(builder.toString());
145 public static String parseToClassName(String token) {
146 token = token.replace(".", "");
147 String correctStr = parseToCamelCase(token);
149 // make first char upper-case
150 char first = Character.toUpperCase(correctStr.charAt(0));
151 correctStr = first + correctStr.substring(1);
155 public static String parseToValidParamName(final String token) {
156 final String validToken = token.replace(".", "");
157 String correctStr = parseToCamelCase(validToken);
159 // make first char lower-case
160 char first = Character.toLowerCase(correctStr.charAt(0));
161 correctStr = first + correctStr.substring(1);
162 return validateParameterName(correctStr);
165 public static String convertToCapitalLetters(final String token) {
166 String convertedStr = token.replace(" ", "_");
167 convertedStr = convertedStr.replace(".", "_");
168 convertedStr = convertedStr.toUpperCase();
172 private static String parseToCamelCase(String token) {
174 throw new NullPointerException("Name can not be null");
177 String correctStr = token.trim();
178 if (correctStr.length() == 0) {
179 throw new IllegalArgumentException("Name can not be emty");
182 correctStr = replaceWithCamelCase(correctStr, ' ');
183 correctStr = replaceWithCamelCase(correctStr, '-');
184 correctStr = replaceWithCamelCase(correctStr, '_');
188 private static String replaceWithCamelCase(String text, char removalChar) {
189 StringBuilder sb = new StringBuilder(text);
190 String toBeRemoved = String.valueOf(removalChar);
192 int toBeRemovedPos = sb.indexOf(toBeRemoved);
193 while (toBeRemovedPos != -1) {
194 sb.replace(toBeRemovedPos, toBeRemovedPos + 1, "");
195 // check if 'toBeRemoved' character is not the only character in
197 if (sb.length() == 0) {
198 throw new IllegalArgumentException("Name can not be '" + toBeRemoved + "'");
200 String replacement = String.valueOf(sb.charAt(toBeRemovedPos)).toUpperCase();
201 sb.setCharAt(toBeRemovedPos, replacement.charAt(0));
202 toBeRemovedPos = sb.indexOf(toBeRemoved);
204 return sb.toString();