opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/GeneratorUtil.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.sal.java.api.generator;
   9
  10 import static org.opendaylight.controller.sal.java.api.generator.Constants.CLASS;
  11 import static org.opendaylight.controller.sal.java.api.generator.Constants.COMMA;
  12 import static org.opendaylight.controller.sal.java.api.generator.Constants.ENUM;
  13 import static org.opendaylight.controller.sal.java.api.generator.Constants.FINAL;
  14 import static org.opendaylight.controller.sal.java.api.generator.Constants.GAP;
  15 import static org.opendaylight.controller.sal.java.api.generator.Constants.IFC;
  16 import static org.opendaylight.controller.sal.java.api.generator.Constants.LB;
  17 import static org.opendaylight.controller.sal.java.api.generator.Constants.LCB;
  18 import static org.opendaylight.controller.sal.java.api.generator.Constants.NL;
  19 import static org.opendaylight.controller.sal.java.api.generator.Constants.PKG;
  20 import static org.opendaylight.controller.sal.java.api.generator.Constants.PRIVATE;
  21 import static org.opendaylight.controller.sal.java.api.generator.Constants.PUBLIC;
  22 import static org.opendaylight.controller.sal.java.api.generator.Constants.RB;
  23 import static org.opendaylight.controller.sal.java.api.generator.Constants.RCB;
  24 import static org.opendaylight.controller.sal.java.api.generator.Constants.SC;
  25 import static org.opendaylight.controller.sal.java.api.generator.Constants.STATIC;
  26 import static org.opendaylight.controller.sal.java.api.generator.Constants.TAB;
  27 import static org.opendaylight.controller.sal.java.api.generator.Constants.EXTENDS;
  28 import static org.opendaylight.controller.sal.java.api.generator.Constants.IMPLEMENTS;
  29
  30 import java.util.ArrayList;
  31 import java.util.List;
  32
  33 import org.opendaylight.controller.sal.binding.model.api.AnnotationType;
  34 import org.opendaylight.controller.sal.binding.model.api.Constant;
  35 import org.opendaylight.controller.sal.binding.model.api.Enumeration;
  36 import org.opendaylight.controller.sal.binding.model.api.Enumeration.Pair;
  37 import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty;
  38 import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
  39 import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
  40 import org.opendaylight.controller.sal.binding.model.api.MethodSignature;
  41 import org.opendaylight.controller.sal.binding.model.api.MethodSignature.Parameter;
  42 import org.opendaylight.controller.sal.binding.model.api.ParameterizedType;
  43 import org.opendaylight.controller.sal.binding.model.api.Type;
  44
  45 public class GeneratorUtil {
  46
  47     private GeneratorUtil() {
  48     }
  49
  50     public static String createIfcDeclarationWithPkgName(
  51             final GeneratedType genType, final String indent) {
  52         return createFileDeclarationWithPkgName(IFC, genType, indent);
  53     }
  54
  55     public static String createClassDeclarationWithPkgName(
  56             final GeneratedTransferObject genTransferObject, final String indent) {
  57         return createFileDeclarationWithPkgName(CLASS, genTransferObject,
  58                 indent);
  59     }
  60
  61     private static String createFileDeclarationWithPkgName(final String type,
  62             final GeneratedType genType, final String indent) {
  63         final StringBuilder builder = new StringBuilder();
  64         builder.append(PKG + GAP + genType.getPackageName() + SC);
  65         builder.append(NL);
  66         builder.append(NL);
  67         createComment(builder, genType.getComment(), indent);
  68
  69         if (!genType.getAnnotations().isEmpty()) {
  70             final List<AnnotationType> annotations = genType.getAnnotations();
  71             appendAnnotations(builder, annotations);
  72             builder.append(NL);
  73         }
  74         builder.append(PUBLIC + GAP + type + GAP + genType.getName() + GAP);
  75
  76         final List<Type> genImplements = genType.getImplements();
  77         if (genType instanceof GeneratedTransferObject) {
  78             GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
  79
  80             if (genTO.getExtends() != null) {
  81                 builder.append(EXTENDS + GAP);
  82                 builder.append(genTO.getExtends() + GAP);
  83             }
  84         }
  85         if (!genImplements.isEmpty()) {
  86             if (genType instanceof GeneratedTransferObject) {
  87                 builder.append(IMPLEMENTS + GAP);
  88             } else {
  89                 builder.append(EXTENDS + GAP);
  90             }
  91             builder.append(getExplicitType(genImplements.get(0)));
  92             for (int i = 1; i < genImplements.size(); ++i) {
  93                 builder.append(", ");
  94                 builder.append(getExplicitType(genImplements.get(i)));
  95             }
  96         }
  97
  98         builder.append(GAP + LCB);
  99         return builder.toString();
 100     }
 101
 102     private static StringBuilder appendAnnotations(final StringBuilder builder,
 103             final List<AnnotationType> annotations) {
 104         if ((builder != null) && (annotations != null)) {
 105             for (final AnnotationType annotation : annotations) {
 106                 builder.append("@");
 107                 builder.append(annotation.getPackageName());
 108                 builder.append(".");
 109                 builder.append(annotation.getName());
 110
 111                 if (annotation.containsParameters()) {
 112                     builder.append("(");
 113                     final List<AnnotationType.Parameter> parameters = annotation
 114                             .getParameters();
 115                     appendAnnotationParams(builder, parameters);
 116                     builder.append(")");
 117                 }
 118             }
 119         }
 120         return builder;
 121     }
 122
 123     private static StringBuilder appendAnnotationParams(
 124             final StringBuilder builder,
 125             final List<AnnotationType.Parameter> parameters) {
 126         if (parameters != null) {
 127             int i = 0;
 128             for (final AnnotationType.Parameter param : parameters) {
 129                 if (param == null) {
 130                     continue;
 131                 }
 132                 if (i > 0) {
 133                     builder.append(", ");
 134                 }
 135                 final String paramName = param.getName();
 136                 if (param.getValue() != null) {
 137                     builder.append(paramName);
 138                     builder.append(" = ");
 139                     builder.append(param.getValue());
 140                 } else {
 141                     builder.append(paramName);
 142                     builder.append(" = {");
 143                     final List<String> values = param.getValues();
 144                     builder.append(values.get(0));
 145                     for (int j = 1; j < values.size(); ++j) {
 146                         builder.append(", ");
 147                         builder.append(values.get(j));
 148                     }
 149                     builder.append("}");
 150                 }
 151                 i++;
 152             }
 153         }
 154         return builder;
 155     }
 156
 157     public static String createConstant(final Constant constant,
 158             final String indent) {
 159         final StringBuilder builder = new StringBuilder();
 160         builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP);
 161         builder.append(getExplicitType(constant.getType()) + GAP
 162                 + constant.getName());
 163         builder.append(GAP + "=" + GAP);
 164         builder.append(constant.getValue() + SC);
 165         return builder.toString();
 166     }
 167
 168     public static String createField(final GeneratedProperty property,
 169             final String indent) {
 170         final StringBuilder builder = new StringBuilder();
 171         builder.append(indent);
 172         if (!property.getAnnotations().isEmpty()) {
 173             final List<AnnotationType> annotations = property.getAnnotations();
 174             appendAnnotations(builder, annotations);
 175             builder.append(NL);
 176         }
 177         builder.append(indent + PRIVATE + GAP);
 178         builder.append(getExplicitType(property.getReturnType()) + GAP
 179                 + property.getName());
 180         builder.append(SC);
 181         return builder.toString();
 182     }
 183
 184     /**
 185      * Create method declaration in interface.
 186      *
 187      * @param method
 188      * @param indent
 189      * @return
 190      */
 191     public static String createMethodDeclaration(final MethodSignature method,
 192             final String indent) {
 193         if (method == null) {
 194             throw new IllegalArgumentException("Method Signature parameter MUST be specified and cannot be NULL!");
 195         }
 196
 197         final String comment = method.getComment();
 198         final String name = method.getName();
 199         if (name == null) {
 200             throw new IllegalStateException("Method Name cannot be NULL!");
 201         }
 202
 203         final Type type = method.getReturnType();
 204         if (type == null) {
 205             throw new IllegalStateException("Method Return type cannot be NULL!");
 206         }
 207
 208         final List<Parameter> parameters = method.getParameters();
 209
 210         final StringBuilder builder = new StringBuilder();
 211         createComment(builder, comment, indent);
 212         builder.append(NL);
 213         builder.append(indent);
 214
 215         if (!method.getAnnotations().isEmpty()) {
 216             final List<AnnotationType> annotations = method.getAnnotations();
 217             appendAnnotations(builder, annotations);
 218             builder.append(NL);
 219         }
 220
 221         builder.append(indent + getExplicitType(type) + GAP + name);
 222         builder.append(LB);
 223         for (int i = 0; i < parameters.size(); i++) {
 224             Parameter p = parameters.get(i);
 225             String separator = COMMA;
 226             if (i + 1 == parameters.size()) {
 227                 separator = "";
 228             }
 229             builder.append(getExplicitType(p.getType()) + GAP + p.getName()
 230                     + separator);
 231         }
 232         builder.append(RB);
 233         builder.append(SC);
 234
 235         return builder.toString();
 236     }
 237
 238     public static String createConstructor(
 239             GeneratedTransferObject genTransferObject, final String indent) {
 240         final StringBuilder builder = new StringBuilder();
 241
 242         final List<GeneratedProperty> properties = genTransferObject
 243                 .getProperties();
 244         final List<GeneratedProperty> ctorParams = new ArrayList<GeneratedProperty>();
 245         for (final GeneratedProperty property : properties) {
 246             if (property.isReadOnly()) {
 247                 ctorParams.add(property);
 248             }
 249         }
 250
 251         builder.append(indent);
 252         builder.append(PUBLIC);
 253         builder.append(GAP);
 254         builder.append(genTransferObject.getName());
 255         builder.append(LB);
 256
 257         if (!ctorParams.isEmpty()) {
 258             builder.append(getExplicitType(ctorParams.get(0).getReturnType()));
 259             builder.append(" ");
 260             builder.append(ctorParams.get(0).getName());
 261             for (int i = 1; i < ctorParams.size(); ++i) {
 262                 final GeneratedProperty param = ctorParams.get(i);
 263                 builder.append(", ");
 264                 builder.append(getExplicitType(param.getReturnType()));
 265                 builder.append(GAP);
 266                 builder.append(param.getName());
 267             }
 268         }
 269         builder.append(RB + GAP + LCB + NL + indent + TAB + "super();" + NL);
 270         if (!ctorParams.isEmpty()) {
 271             for (final GeneratedProperty property : ctorParams) {
 272                 builder.append(indent);
 273                 builder.append(TAB);
 274                 builder.append("this.");
 275                 builder.append(property.getName());
 276                 builder.append(" = ");
 277                 builder.append(property.getName());
 278                 builder.append(SC);
 279                 builder.append(NL);
 280             }
 281         }
 282         builder.append(indent);
 283         builder.append(RCB);
 284         return builder.toString();
 285     }
 286
 287     public static String createGetter(final GeneratedProperty property,
 288             final String indent) {
 289         final StringBuilder builder = new StringBuilder();
 290
 291         final Type type = property.getReturnType();
 292         final String varName = property.getName();
 293         final char first = Character.toUpperCase(varName.charAt(0));
 294         final String methodName = "get" + first + varName.substring(1);
 295
 296         builder.append(indent + PUBLIC + GAP + getExplicitType(type) + GAP
 297                 + methodName);
 298         builder.append(LB + RB + LCB + NL);
 299
 300         String currentIndent = indent + TAB;
 301
 302         builder.append(currentIndent + "return " + varName + SC + NL);
 303
 304         builder.append(indent + RCB);
 305         return builder.toString();
 306     }
 307
 308     public static String createSetter(final GeneratedProperty property,
 309             final String indent) {
 310         final StringBuilder builder = new StringBuilder();
 311
 312         final Type type = property.getReturnType();
 313         final String varName = property.getName();
 314         final char first = Character.toUpperCase(varName.charAt(0));
 315         final String methodName = "set" + first + varName.substring(1);
 316
 317         builder.append(indent + PUBLIC + GAP + "void" + GAP
 318                 + methodName);
 319         builder.append(LB + getExplicitType(type) + GAP + varName + RB + LCB + NL);
 320         String currentIndent = indent + TAB;
 321         builder.append(currentIndent + "this." + varName + " = " + varName + SC + NL);
 322         builder.append(indent + RCB);
 323         return builder.toString();
 324     }
 325
 326     public static String createHashCode(
 327             final List<GeneratedProperty> properties, final String indent) {
 328         StringBuilder builder = new StringBuilder();
 329         builder.append(indent + "public int hashCode() {" + NL);
 330         builder.append(indent + TAB + "final int prime = 31;" + NL);
 331         builder.append(indent + TAB + "int result = 1;" + NL);
 332
 333         for (GeneratedProperty property : properties) {
 334             String fieldName = property.getName();
 335             builder.append(indent + TAB + "result = prime * result + (("
 336                     + fieldName + " == null) ? 0 : " + fieldName
 337                     + ".hashCode());" + NL);
 338         }
 339
 340         builder.append(indent + TAB + "return result;" + NL);
 341         builder.append(indent + RCB + NL);
 342         return builder.toString();
 343     }
 344
 345     public static String createEquals(final GeneratedTransferObject type,
 346             final List<GeneratedProperty> properties, final String indent) {
 347         StringBuilder builder = new StringBuilder();
 348         final String indent1 = indent + TAB;
 349         final String indent2 = indent + TAB + TAB;
 350         final String indent3 = indent + TAB + TAB + TAB;
 351
 352         builder.append(indent + "public boolean equals(Object obj) {" + NL);
 353         builder.append(indent1 + "if (this == obj) {" + NL);
 354         builder.append(indent2 + "return true;" + NL);
 355         builder.append(indent1 + "}" + NL);
 356         builder.append(indent1 + "if (obj == null) {" + NL);
 357         builder.append(indent2 + "return false;" + NL);
 358         builder.append(indent1 + "}" + NL);
 359         builder.append(indent1 + "if (getClass() != obj.getClass()) {" + NL);
 360         builder.append(indent2 + "return false;" + NL);
 361         builder.append(indent1 + "}" + NL);
 362
 363         String typeStr = type.getPackageName() + "." + type.getName();
 364         builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;"
 365                 + NL);
 366
 367         for (GeneratedProperty property : properties) {
 368             String fieldName = property.getName();
 369             builder.append(indent1 + "if (" + fieldName + " == null) {" + NL);
 370             builder.append(indent2 + "if (other." + fieldName + " != null) {"
 371                     + NL);
 372             builder.append(indent3 + "return false;" + NL);
 373             builder.append(indent2 + "}" + NL);
 374             builder.append(indent1 + "} else if (!" + fieldName
 375                     + ".equals(other." + fieldName + ")) {" + NL);
 376             builder.append(indent2 + "return false;" + NL);
 377             builder.append(indent1 + "}" + NL);
 378         }
 379
 380         builder.append(indent1 + "return true;" + NL);
 381
 382         builder.append(indent + RCB + NL);
 383         return builder.toString();
 384     }
 385
 386     public static String createToString(final GeneratedTransferObject type,
 387             final List<GeneratedProperty> properties, final String indent) {
 388         StringBuilder builder = new StringBuilder();
 389         builder.append(indent);
 390         builder.append("public String toString() {");
 391         builder.append(NL);
 392         builder.append(indent);
 393         builder.append(TAB);
 394         builder.append("StringBuilder builder = new StringBuilder();");
 395         builder.append(NL);
 396         builder.append(indent);
 397         builder.append(TAB);
 398         builder.append("builder.append(\"");
 399         builder.append(type.getName());
 400         builder.append(" [");
 401
 402         boolean first = true;
 403         for (GeneratedProperty property : properties) {
 404             if (first) {
 405                 builder.append(property.getName());
 406                 builder.append("=\");");
 407                 builder.append(NL);
 408                 builder.append(indent);
 409                 builder.append(TAB);
 410                 builder.append("builder.append(");
 411                 builder.append(property.getName());
 412                 builder.append(");");
 413                 first = false;
 414             } else {
 415                 builder.append(NL);
 416                 builder.append(indent);
 417                 builder.append(TAB);
 418                 builder.append("builder.append(\", ");
 419                 builder.append(property.getName());
 420                 builder.append("=\");");
 421                 builder.append(NL);
 422                 builder.append(indent);
 423                 builder.append(TAB);
 424                 builder.append("builder.append(\", ");
 425                 builder.append(property.getName());
 426                 builder.append(");");
 427             }
 428         }
 429         builder.append(NL);
 430         builder.append(indent);
 431         builder.append(TAB);
 432         builder.append("builder.append(\"]\");");
 433         builder.append(NL);
 434         builder.append(indent);
 435         builder.append(TAB);
 436         builder.append("return builder.toString();");
 437
 438         builder.append(NL);
 439         builder.append(indent);
 440         builder.append(RCB);
 441         builder.append(NL);
 442         return builder.toString();
 443     }
 444
 445     public static String createEnum(final Enumeration enumeration,
 446             final String indent) {
 447         final StringBuilder builder = new StringBuilder(indent + ENUM + GAP
 448                 + enumeration.getName() + GAP + LCB + NL);
 449
 450         String separator = COMMA;
 451         final List<Pair> values = enumeration.getValues();
 452         builder.append(indent + TAB);
 453         for (int i = 0; i < values.size(); i++) {
 454             if (i + 1 == values.size()) {
 455                 separator = SC;
 456             }
 457             builder.append(values.get(i).getName() + separator);
 458         }
 459         builder.append(NL);
 460         builder.append(indent + RCB);
 461         return builder.toString();
 462     }
 463
 464     private static String getExplicitType(final Type type) {
 465         if (type == null) {
 466             throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!");
 467         }
 468         String packageName = type.getPackageName();
 469         if (packageName.endsWith(".")) {
 470             packageName = packageName.substring(0, packageName.length() - 1);
 471         }
 472
 473         final StringBuilder builder = new StringBuilder(packageName + "."
 474                 + type.getName());
 475         if (type instanceof ParameterizedType) {
 476             final ParameterizedType pType = (ParameterizedType) type;
 477             Type[] pTypes = pType.getActualTypeArguments();
 478             builder.append("<");
 479             builder.append(getParameters(pTypes));
 480             builder.append(">");
 481         }
 482         if (builder.toString().equals("java.lang.Void")) {
 483             return "void";
 484         }
 485         return builder.toString();
 486     }
 487
 488     private static String getParameters(final Type[] pTypes) {
 489         final StringBuilder builder = new StringBuilder();
 490         for (int i = 0; i < pTypes.length; i++) {
 491             Type t = pTypes[i];
 492
 493             String separator = COMMA;
 494             if (i + 1 == pTypes.length) {
 495                 separator = "";
 496             }
 497             builder.append(getExplicitType(t) + separator);
 498         }
 499         return builder.toString();
 500     }
 501
 502     private static void createComment(final StringBuilder builder,
 503             final String comment, final String indent) {
 504         if (comment != null && comment.length() > 0) {
 505             builder.append(indent + "/*" + NL);
 506             builder.append(indent + comment + NL);
 507             builder.append(indent + "*/" + NL);
 508         }
 509     }
 510
 511 }