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 org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
   4 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder;
   5 import org.opendaylight.controller.yang.common.QName;
   6 import org.opendaylight.controller.yang.model.api.*;
   7
   8 import java.util.*;
   9
  10 public class BindingGeneratorUtil {
  11
  12     private static final String[] SET_VALUES = new String[]{"abstract",
  13             "assert", "boolean", "break", "byte", "case", "catch", "char",
  14             "class", "const", "continue", "default", "double", "do", "else",
  15             "enum", "extends", "false", "final", "finally", "float", "for",
  16             "goto", "if", "implements", "import", "instanceof", "int",
  17             "interface", "long", "native", "new", "null", "package", "private",
  18             "protected", "public", "return", "short", "static", "strictfp",
  19             "super", "switch", "synchronized", "this", "throw", "throws",
  20             "transient", "true", "try", "void", "volatile", "while"};
  21
  22     private BindingGeneratorUtil() {}
  23
  24     public static final Set<String> JAVA_RESERVED_WORDS = new HashSet<String>(
  25             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(
  57             final String packageName, final SchemaNode schemaNode,
  58             final String transObjectName) {
  59         if (packageName != null && schemaNode != null
  60                 && transObjectName != null) {
  61
  62             final String genTOName = BindingGeneratorUtil
  63                     .parseToClassName(transObjectName);
  64             final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(
  65                     packageName, genTOName);
  66
  67             return newType;
  68
  69         }
  70         return null;
  71     }
  72
  73     public static String moduleNamespaceToPackageName(
  74             final Module module) {
  75         final StringBuilder packageNameBuilder = new StringBuilder();
  76
  77         final Calendar calendar = Calendar.getInstance();
  78         if (module.getRevision() == null) {
  79             throw new IllegalArgumentException("Module " + module.getName()
  80                     + " does not specify revision date!");
  81         }
  82         packageNameBuilder.append("org.opendaylight.yang.gen.v");
  83         packageNameBuilder.append(module.getYangVersion());
  84         packageNameBuilder.append(".");
  85
  86         String namespace = module.getNamespace().toString();
  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("+", ".");
  97         namespace = namespace.replace(",", ".");
  98         namespace = namespace.replace(";", ".");
  99         namespace = namespace.replace("=", ".");
 100
 101         packageNameBuilder.append(namespace);
 102         calendar.setTime(module.getRevision());
 103         packageNameBuilder.append(".rev");
 104         packageNameBuilder.append(calendar.get(Calendar.YEAR));
 105         packageNameBuilder.append((calendar.get(Calendar.MONTH) + 1));
 106         packageNameBuilder.append(calendar.get(Calendar.DAY_OF_MONTH));
 107
 108         return validateJavaPackage(packageNameBuilder.toString());
 109     }
 110
 111     public static String packageNameForGeneratedType(
 112             final String basePackageName, final SchemaPath schemaPath) {
 113         final StringBuilder builder = new StringBuilder();
 114         builder.append(basePackageName);
 115         if ((schemaPath != null) && (schemaPath.getPath() != null)) {
 116             final List<QName> pathToNode = schemaPath.getPath();
 117             final int traversalSteps = (pathToNode.size() - 1);
 118             for (int i = 0; i < traversalSteps; ++i) {
 119                 builder.append(".");
 120                 String nodeLocalName = pathToNode.get(i).getLocalName();
 121
 122                 nodeLocalName = nodeLocalName.replace(":", ".");
 123                 nodeLocalName = nodeLocalName.replace("-", ".");
 124                 builder.append(nodeLocalName);
 125             }
 126             return validateJavaPackage(builder.toString());
 127         }
 128         return null;
 129     }
 130
 131     public static String parseToClassName(String token) {
 132         token = token.replace(".", "");
 133         String correctStr = parseToCamelCase(token);
 134
 135         // make first char upper-case
 136         char first = Character.toUpperCase(correctStr.charAt(0));
 137         correctStr = first + correctStr.substring(1);
 138         return correctStr;
 139     }
 140
 141     public static String parseToValidParamName(final String token) {
 142         final String validToken = token.replace(".", "");
 143         String correctStr = parseToCamelCase(validToken);
 144
 145         // make first char lower-case
 146         char first = Character.toLowerCase(correctStr.charAt(0));
 147         correctStr = first + correctStr.substring(1);
 148         return validateParameterName(correctStr);
 149     }
 150
 151     private static String parseToCamelCase(String token) {
 152         if (token == null) {
 153             throw new NullPointerException("Name can not be null");
 154         }
 155
 156         String correctStr = token.trim();
 157         if (correctStr.length() == 0) {
 158             throw new IllegalArgumentException("Name can not be emty");
 159         }
 160
 161         correctStr = replaceWithCamelCase(correctStr, ' ');
 162         correctStr = replaceWithCamelCase(correctStr, '-');
 163         correctStr = replaceWithCamelCase(correctStr, '_');
 164         return correctStr;
 165     }
 166
 167     private static String replaceWithCamelCase(String text, char removalChar) {
 168         StringBuilder sb = new StringBuilder(text);
 169         String toBeRemoved = String.valueOf(removalChar);
 170
 171         int toBeRemovedPos = sb.indexOf(toBeRemoved);
 172         while (toBeRemovedPos != -1) {
 173             sb.replace(toBeRemovedPos, toBeRemovedPos + 1, "");
 174             // check if 'toBeRemoved' character is not the only character in
 175             // 'text'
 176             if (sb.length() == 0) {
 177                 throw new IllegalArgumentException("Name can not be '"
 178                         + toBeRemoved + "'");
 179             }
 180             String replacement = String.valueOf(sb.charAt(toBeRemovedPos))
 181                     .toUpperCase();
 182             sb.setCharAt(toBeRemovedPos, replacement.charAt(0));
 183             toBeRemovedPos = sb.indexOf(toBeRemoved);
 184         }
 185         return sb.toString();
 186     }
 187 }