opendaylight/sal/yang-prototype/code-generator/binding-generator-util/src/main/java/org/opendaylight/controller/binding/generator/util/BindingGeneratorUtil.java

   1 package org.opendaylight.controller.binding.generator.util;
   2
   3 import java.util.*;
   4
   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;
  12
  13 public final class BindingGeneratorUtil {
  14
  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" };
  21
  22     private BindingGeneratorUtil() {
  23     }
  24
  25     public static final Set<String> JAVA_RESERVED_WORDS = new HashSet<String>(Arrays.asList(SET_VALUES));
  26
  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                     if (JAVA_RESERVED_WORDS.contains(packNameParts[i])) {
  34                         packNameParts[i] = "_" + packNameParts[i];
  35                     }
  36                     if (i > 0) {
  37                         builder.append(".");
  38                     }
  39                     builder.append(packNameParts[i]);
  40                 }
  41                 return builder.toString();
  42             }
  43         }
  44         return packageName;
  45     }
  46
  47     public static String validateParameterName(final String parameterName) {
  48         if (parameterName != null) {
  49             if (JAVA_RESERVED_WORDS.contains(parameterName)) {
  50                 return "_" + parameterName;
  51             }
  52         }
  53         return parameterName;
  54     }
  55
  56     public static GeneratedTOBuilder schemaNodeToTransferObjectBuilder(final String packageName,
  57             final SchemaNode schemaNode, final String transObjectName) {
  58         if (packageName != null && schemaNode != null && transObjectName != null) {
  59
  60             final String genTOName = BindingGeneratorUtil.parseToClassName(transObjectName);
  61             final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(packageName, genTOName);
  62
  63             return newType;
  64
  65         }
  66         return null;
  67     }
  68
  69     public static String moduleNamespaceToPackageName(final Module module) {
  70         final StringBuilder packageNameBuilder = new StringBuilder();
  71
  72         final Calendar calendar = Calendar.getInstance();
  73         if (module.getRevision() == null) {
  74             throw new IllegalArgumentException("Module " + module.getName() + " does not specify revision date!");
  75         }
  76         packageNameBuilder.append("org.opendaylight.yang.gen.v");
  77         packageNameBuilder.append(module.getYangVersion());
  78         packageNameBuilder.append(".");
  79
  80         String namespace = module.getNamespace().toString();
  81         namespace = namespace.replace("://", ".");
  82         namespace = namespace.replace("/", ".");
  83         namespace = namespace.replace(":", ".");
  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
  95         packageNameBuilder.append(namespace);
  96         calendar.setTime(module.getRevision());
  97         packageNameBuilder.append(".rev");
  98         packageNameBuilder.append(calendar.get(Calendar.YEAR));
  99         packageNameBuilder.append((calendar.get(Calendar.MONTH) + 1));
 100         packageNameBuilder.append(calendar.get(Calendar.DAY_OF_MONTH));
 101
 102         return validateJavaPackage(packageNameBuilder.toString());
 103     }
 104
 105     public static String packageNameForGeneratedType(final String basePackageName, final SchemaPath schemaPath) {
 106         if (basePackageName == null) {
 107             throw new IllegalArgumentException("Base Package Name cannot be NULL!");
 108         }
 109         if (schemaPath == null) {
 110             throw new IllegalArgumentException("Schema Path cannot be NULL!");
 111         }
 112
 113         final StringBuilder builder = new StringBuilder();
 114         builder.append(basePackageName);
 115         final List<QName> pathToNode = schemaPath.getPath();
 116         final int traversalSteps = (pathToNode.size() - 1);
 117         for (int i = 0; i < traversalSteps; ++i) {
 118             builder.append(".");
 119             String nodeLocalName = pathToNode.get(i).getLocalName();
 120
 121             nodeLocalName = nodeLocalName.replace(":", ".");
 122             nodeLocalName = nodeLocalName.replace("-", ".");
 123             builder.append(nodeLocalName);
 124         }
 125         return validateJavaPackage(builder.toString());
 126     }
 127
 128     public static String packageNameForTypeDefinition(final String basePackageName,
 129             final TypeDefinition<?> typeDefinition) {
 130         if (basePackageName == null) {
 131             throw new IllegalArgumentException("Base Package Name cannot be NULL!");
 132         }
 133         if (typeDefinition == null) {
 134             throw new IllegalArgumentException("Type Definition reference cannot be NULL!");
 135         }
 136
 137         final StringBuilder builder = new StringBuilder();
 138         builder.append(basePackageName);
 139         return validateJavaPackage(builder.toString());
 140     }
 141
 142     public static String parseToClassName(String token) {
 143         token = token.replace(".", "");
 144         String correctStr = parseToCamelCase(token);
 145
 146         // make first char upper-case
 147         char first = Character.toUpperCase(correctStr.charAt(0));
 148         correctStr = first + correctStr.substring(1);
 149         return correctStr;
 150     }
 151
 152     public static String parseToValidParamName(final String token) {
 153         final String validToken = token.replace(".", "");
 154         String correctStr = parseToCamelCase(validToken);
 155
 156         // make first char lower-case
 157         char first = Character.toLowerCase(correctStr.charAt(0));
 158         correctStr = first + correctStr.substring(1);
 159         return validateParameterName(correctStr);
 160     }
 161
 162     public static String convertToCapitalLetters(final String token) {
 163         String convertedStr = token.replace(" ", "_");
 164         convertedStr = convertedStr.replace(".", "_");
 165         convertedStr = convertedStr.toUpperCase();
 166         return convertedStr;
 167     }
 168
 169     private static String parseToCamelCase(String token) {
 170         if (token == null) {
 171             throw new NullPointerException("Name can not be null");
 172         }
 173
 174         String correctStr = token.trim();
 175         if (correctStr.length() == 0) {
 176             throw new IllegalArgumentException("Name can not be emty");
 177         }
 178
 179         correctStr = replaceWithCamelCase(correctStr, ' ');
 180         correctStr = replaceWithCamelCase(correctStr, '-');
 181         correctStr = replaceWithCamelCase(correctStr, '_');
 182         return correctStr;
 183     }
 184
 185     private static String replaceWithCamelCase(String text, char removalChar) {
 186         StringBuilder sb = new StringBuilder(text);
 187         String toBeRemoved = String.valueOf(removalChar);
 188
 189         int toBeRemovedPos = sb.indexOf(toBeRemoved);
 190         while (toBeRemovedPos != -1) {
 191             sb.replace(toBeRemovedPos, toBeRemovedPos + 1, "");
 192             // check if 'toBeRemoved' character is not the only character in
 193             // 'text'
 194             if (sb.length() == 0) {
 195                 throw new IllegalArgumentException("Name can not be '" + toBeRemoved + "'");
 196             }
 197             String replacement = String.valueOf(sb.charAt(toBeRemovedPos)).toUpperCase();
 198             sb.setCharAt(toBeRemovedPos, replacement.charAt(0));
 199             toBeRemovedPos = sb.indexOf(toBeRemoved);
 200         }
 201         return sb.toString();
 202     }
 203 }