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.Module;
   7 import org.opendaylight.controller.yang.model.api.SchemaNode;
   8 import org.opendaylight.controller.yang.model.api.SchemaPath;
   9 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  10
  11 import java.util.*;
  12
  13 public final class BindingGeneratorUtil {
  14
  15     private static final String[] SET_VALUES = new String[]{"abstract",
  16             "assert", "boolean", "break", "byte", "case", "catch", "char",
  17             "class", "const", "continue", "default", "double", "do", "else",
  18             "enum", "extends", "false", "final", "finally", "float", "for",
  19             "goto", "if", "implements", "import", "instanceof", "int",
  20             "interface", "long", "native", "new", "null", "package", "private",
  21             "protected", "public", "return", "short", "static", "strictfp",
  22             "super", "switch", "synchronized", "this", "throw", "throws",
  23             "transient", "true", "try", "void", "volatile", "while"};
  24
  25     private BindingGeneratorUtil() {
  26     }
  27
  28     public static final Set<String> JAVA_RESERVED_WORDS = new HashSet<String>(
  29             Arrays.asList(SET_VALUES));
  30
  31     public static String validateJavaPackage(final String packageName) {
  32         if (packageName != null) {
  33             final String[] packNameParts = packageName.split("\\.");
  34             if (packNameParts != null) {
  35                 final StringBuilder builder = new StringBuilder();
  36                 for (int i = 0; i < packNameParts.length; ++i) {
  37                     if (JAVA_RESERVED_WORDS.contains(packNameParts[i])) {
  38                         packNameParts[i] = "_" + packNameParts[i];
  39                     }
  40                     if (i > 0) {
  41                         builder.append(".");
  42                     }
  43                     builder.append(packNameParts[i]);
  44                 }
  45                 return builder.toString();
  46             }
  47         }
  48         return packageName;
  49     }
  50
  51     public static String validateParameterName(final String parameterName) {
  52         if (parameterName != null) {
  53             if (JAVA_RESERVED_WORDS.contains(parameterName)) {
  54                 return "_" + parameterName;
  55             }
  56         }
  57         return parameterName;
  58     }
  59
  60     public static GeneratedTOBuilder schemaNodeToTransferObjectBuilder(
  61             final String packageName, final SchemaNode schemaNode,
  62             final String transObjectName) {
  63         if (packageName != null && schemaNode != null
  64                 && transObjectName != null) {
  65
  66             final String genTOName = BindingGeneratorUtil
  67                     .parseToClassName(transObjectName);
  68             final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(
  69                     packageName, genTOName);
  70
  71             return newType;
  72
  73         }
  74         return null;
  75     }
  76
  77     public static String moduleNamespaceToPackageName(
  78             final Module module) {
  79         final StringBuilder packageNameBuilder = new StringBuilder();
  80
  81         final Calendar calendar = Calendar.getInstance();
  82         if (module.getRevision() == null) {
  83             throw new IllegalArgumentException("Module " + module.getName()
  84                     + " does not specify revision date!");
  85         }
  86         packageNameBuilder.append("org.opendaylight.yang.gen.v");
  87         packageNameBuilder.append(module.getYangVersion());
  88         packageNameBuilder.append(".");
  89
  90         String namespace = module.getNamespace().toString();
  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         namespace = namespace.replace("+", ".");
 101         namespace = namespace.replace(",", ".");
 102         namespace = namespace.replace(";", ".");
 103         namespace = namespace.replace("=", ".");
 104
 105         packageNameBuilder.append(namespace);
 106         calendar.setTime(module.getRevision());
 107         packageNameBuilder.append(".rev");
 108         packageNameBuilder.append(calendar.get(Calendar.YEAR));
 109         packageNameBuilder.append((calendar.get(Calendar.MONTH) + 1));
 110         packageNameBuilder.append(calendar.get(Calendar.DAY_OF_MONTH));
 111
 112         return validateJavaPackage(packageNameBuilder.toString());
 113     }
 114
 115     public static String packageNameForGeneratedType(
 116             final String basePackageName, final SchemaPath schemaPath) {
 117         if (basePackageName == null) {
 118             throw new IllegalArgumentException("Base Package Name cannot be " +
 119                     "NULL!");
 120         }
 121         if (schemaPath == null) {
 122             throw new IllegalArgumentException("Schema Path cannot be NULL!");
 123         }
 124
 125         final StringBuilder builder = new StringBuilder();
 126         builder.append(basePackageName);
 127         final List<QName> pathToNode = schemaPath.getPath();
 128         final int traversalSteps = (pathToNode.size() - 1);
 129         for (int i = 0; i < traversalSteps; ++i) {
 130             builder.append(".");
 131             String nodeLocalName = pathToNode.get(i).getLocalName();
 132
 133             nodeLocalName = nodeLocalName.replace(":", ".");
 134             nodeLocalName = nodeLocalName.replace("-", ".");
 135             builder.append(nodeLocalName);
 136         }
 137         return validateJavaPackage(builder.toString());
 138     }
 139
 140     public static String packageNameForTypeDefinition(
 141             final String basePackageName, final TypeDefinition<?> typeDefinition) {
 142         if (basePackageName == null) {
 143             throw new IllegalArgumentException("Base Package Name cannot be " +
 144                     "NULL!");
 145         }
 146         if (typeDefinition == null) {
 147             throw new IllegalArgumentException("Type Definition reference " +
 148                     "cannot be NULL!");
 149         }
 150
 151         final StringBuilder builder = new StringBuilder();
 152         builder.append(basePackageName);
 153         return validateJavaPackage(builder.toString());
 154     }
 155
 156     public static String parseToClassName(String token) {
 157         token = token.replace(".", "");
 158         String correctStr = parseToCamelCase(token);
 159
 160         // make first char upper-case
 161         char first = Character.toUpperCase(correctStr.charAt(0));
 162         correctStr = first + correctStr.substring(1);
 163         return correctStr;
 164     }
 165
 166     public static String parseToValidParamName(final String token) {
 167         final String validToken = token.replace(".", "");
 168         String correctStr = parseToCamelCase(validToken);
 169
 170         // make first char lower-case
 171         char first = Character.toLowerCase(correctStr.charAt(0));
 172         correctStr = first + correctStr.substring(1);
 173         return validateParameterName(correctStr);
 174     }
 175
 176     private static String parseToCamelCase(String token) {
 177         if (token == null) {
 178             throw new NullPointerException("Name can not be null");
 179         }
 180
 181         String correctStr = token.trim();
 182         if (correctStr.length() == 0) {
 183             throw new IllegalArgumentException("Name can not be emty");
 184         }
 185
 186         correctStr = replaceWithCamelCase(correctStr, ' ');
 187         correctStr = replaceWithCamelCase(correctStr, '-');
 188         correctStr = replaceWithCamelCase(correctStr, '_');
 189         return correctStr;
 190     }
 191
 192     private static String replaceWithCamelCase(String text, char removalChar) {
 193         StringBuilder sb = new StringBuilder(text);
 194         String toBeRemoved = String.valueOf(removalChar);
 195
 196         int toBeRemovedPos = sb.indexOf(toBeRemoved);
 197         while (toBeRemovedPos != -1) {
 198             sb.replace(toBeRemovedPos, toBeRemovedPos + 1, "");
 199             // check if 'toBeRemoved' character is not the only character in
 200             // 'text'
 201             if (sb.length() == 0) {
 202                 throw new IllegalArgumentException("Name can not be '"
 203                         + toBeRemoved + "'");
 204             }
 205             String replacement = String.valueOf(sb.charAt(toBeRemovedPos))
 206                     .toUpperCase();
 207             sb.setCharAt(toBeRemovedPos, replacement.charAt(0));
 208             toBeRemovedPos = sb.indexOf(toBeRemoved);
 209         }
 210         return sb.toString();
 211     }
 212 }