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