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                     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;
  38                     }
  39                     if (i > 0) {
  40                         builder.append(".");
  41                     }
  42                     builder.append(packNameParts[i]);
  43                 }
  44                 return builder.toString();
  45             }
  46         }
  47         return packageName;
  48     }
  49
  50     public static String validateParameterName(final String parameterName) {
  51         if (parameterName != null) {
  52             if (JAVA_RESERVED_WORDS.contains(parameterName)) {
  53                 return "_" + parameterName;
  54             }
  55         }
  56         return parameterName;
  57     }
  58
  59     public static GeneratedTOBuilder schemaNodeToTransferObjectBuilder(final String packageName,
  60             final SchemaNode schemaNode, final String transObjectName) {
  61         if (packageName != null && schemaNode != null && transObjectName != null) {
  62
  63             final String genTOName = BindingGeneratorUtil.parseToClassName(transObjectName);
  64             final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(packageName, genTOName);
  65
  66             return newType;
  67
  68         }
  69         return null;
  70     }
  71
  72     public static String moduleNamespaceToPackageName(final Module module) {
  73         final StringBuilder packageNameBuilder = new StringBuilder();
  74
  75         final Calendar calendar = Calendar.getInstance();
  76         if (module.getRevision() == null) {
  77             throw new IllegalArgumentException("Module " + module.getName() + " does not specify revision date!");
  78         }
  79         packageNameBuilder.append("org.opendaylight.yang.gen.v");
  80         packageNameBuilder.append(module.getYangVersion());
  81         packageNameBuilder.append(".");
  82
  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("=", ".");
  97
  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));
 104
 105         return validateJavaPackage(packageNameBuilder.toString());
 106     }
 107
 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!");
 111         }
 112         if (schemaPath == null) {
 113             throw new IllegalArgumentException("Schema Path cannot be NULL!");
 114         }
 115
 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) {
 121             builder.append(".");
 122             String nodeLocalName = pathToNode.get(i).getLocalName();
 123
 124             nodeLocalName = nodeLocalName.replace(":", ".");
 125             nodeLocalName = nodeLocalName.replace("-", ".");
 126             builder.append(nodeLocalName);
 127         }
 128         return validateJavaPackage(builder.toString());
 129     }
 130
 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!");
 135         }
 136         if (typeDefinition == null) {
 137             throw new IllegalArgumentException("Type Definition reference cannot be NULL!");
 138         }
 139
 140         final StringBuilder builder = new StringBuilder();
 141         builder.append(basePackageName);
 142         return validateJavaPackage(builder.toString());
 143     }
 144
 145     public static String parseToClassName(String token) {
 146         token = token.replace(".", "");
 147         String correctStr = parseToCamelCase(token);
 148
 149         // make first char upper-case
 150         char first = Character.toUpperCase(correctStr.charAt(0));
 151         correctStr = first + correctStr.substring(1);
 152         return correctStr;
 153     }
 154
 155     public static String parseToValidParamName(final String token) {
 156         final String validToken = token.replace(".", "");
 157         String correctStr = parseToCamelCase(validToken);
 158
 159         // make first char lower-case
 160         char first = Character.toLowerCase(correctStr.charAt(0));
 161         correctStr = first + correctStr.substring(1);
 162         return validateParameterName(correctStr);
 163     }
 164
 165     public static String convertToCapitalLetters(final String token) {
 166         String convertedStr = token.replace(" ", "_");
 167         convertedStr = convertedStr.replace(".", "_");
 168         convertedStr = convertedStr.toUpperCase();
 169         return convertedStr;
 170     }
 171
 172     private static String parseToCamelCase(String token) {
 173         if (token == null) {
 174             throw new NullPointerException("Name can not be null");
 175         }
 176
 177         String correctStr = token.trim();
 178         if (correctStr.length() == 0) {
 179             throw new IllegalArgumentException("Name can not be emty");
 180         }
 181
 182         correctStr = replaceWithCamelCase(correctStr, ' ');
 183         correctStr = replaceWithCamelCase(correctStr, '-');
 184         correctStr = replaceWithCamelCase(correctStr, '_');
 185         return correctStr;
 186     }
 187
 188     private static String replaceWithCamelCase(String text, char removalChar) {
 189         StringBuilder sb = new StringBuilder(text);
 190         String toBeRemoved = String.valueOf(removalChar);
 191
 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
 196             // 'text'
 197             if (sb.length() == 0) {
 198                 throw new IllegalArgumentException("Name can not be '" + toBeRemoved + "'");
 199             }
 200             String replacement = String.valueOf(sb.charAt(toBeRemovedPos)).toUpperCase();
 201             sb.setCharAt(toBeRemovedPos, replacement.charAt(0));
 202             toBeRemovedPos = sb.indexOf(toBeRemoved);
 203         }
 204         return sb.toString();
 205     }
 206 }