code-generator/binding-java-api-generator/src/main/java/org/opendaylight/yangtools/sal/java/api/generator/ClassTemplate.xtend

   1 package org.opendaylight.yangtools.sal.java.api.generator\r
   2 \r
   3 import java.util.List\r
   4 import org.opendaylight.yangtools.binding.generator.util.TypeConstants\r
   5 import org.opendaylight.yangtools.sal.binding.model.api.Constant\r
   6 import org.opendaylight.yangtools.sal.binding.model.api.Enumeration\r
   7 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty\r
   8 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject\r
   9 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType\r
  10 \r
  11 \r
  12 /**\r
  13  * Template for generating JAVA class. \r
  14  */\r
  15 class ClassTemplate extends BaseTemplate {\r
  16 \r
  17     protected val List<GeneratedProperty> properties\r
  18     protected val List<GeneratedProperty> finalProperties\r
  19     protected val List<GeneratedProperty> parentProperties\r
  20     protected val Iterable<GeneratedProperty> allProperties;\r
  21     \r
  22     /**\r
  23      * List of enumeration which are generated as JAVA enum type.\r
  24      */\r
  25     protected val List<Enumeration> enums\r
  26     \r
  27     /**\r
  28      * List of constant instances which are generated as JAVA public static final attributes.\r
  29      */\r
  30     protected val List<Constant> consts\r
  31     \r
  32     /**\r
  33      * List of generated types which are enclosed inside <code>genType</code>\r
  34      */\r
  35     protected val List<GeneratedType> enclosedGeneratedTypes;\r
  36     \r
  37     \r
  38     protected val GeneratedTransferObject genTO;\r
  39     \r
  40     /**\r
  41      * Creates instance of this class with concrete <code>genType</code>.\r
  42      * \r
  43      * @param genType generated transfer object which will be transformed to JAVA class source code\r
  44      */\r
  45     new(GeneratedTransferObject genType) {\r
  46         super(genType)\r
  47         this.genTO = genType\r
  48         this.properties = genType.properties\r
  49         this.finalProperties = GeneratorUtil.resolveReadOnlyPropertiesFromTO(genTO.properties)\r
  50         this.parentProperties = GeneratorUtil.getPropertiesOfAllParents(genTO)\r
  51         this.allProperties = properties + parentProperties\r
  52         this.enums = genType.enumerations\r
  53         this.consts = genType.constantDefinitions\r
  54         this.enclosedGeneratedTypes = genType.enclosedTypes\r
  55     }\r
  56     \r
  57 \r
  58     \r
  59     \r
  60     \r
  61     /**\r
  62      * Generates JAVA class source code (class body only).\r
  63      * \r
  64      * @return string with JAVA class body source code\r
  65      */\r
  66     def generateAsInnerClass() {\r
  67         return generateBody(true)\r
  68     }\r
  69     \r
  70 \r
  71     \r
  72     override protected body() {\r
  73         generateBody(false);\r
  74     }\r
  75 \r
  76     /**\r
  77      * Template method which generates class body.\r
  78      * \r
  79      * @param isInnerClass boolean value which specify if generated class is|isn't inner\r
  80      * @return string with class source code in JAVA format\r
  81      */\r
  82     def protected generateBody(boolean isInnerClass) '''\r
  83         «type.comment.asJavadoc»\r
  84         «generateClassDeclaration(isInnerClass)» {\r
  85                 «innerClassesDeclarations»\r
  86             «enumDeclarations»\r
  87             «constantsDeclarations»\r
  88             «generateFields»\r
  89             «constructors»\r
  90             «FOR field : properties SEPARATOR "\n"»\r
  91                 «field.getterMethod»\r
  92                 «IF !field.readOnly»\r
  93                     «field.setterMethod»\r
  94                 «ENDIF»\r
  95             «ENDFOR»\r
  96             «generateHashCode»\r
  97             «generateEquals»\r
  98             «generateToString»\r
  99         \r
 100         }\r
 101     '''\r
 102     \r
 103     \r
 104     /**\r
 105      * Template method which generates inner classes inside this interface.\r
 106      * \r
 107      * @return string with the source code for inner classes in JAVA format\r
 108      */\r
 109     def protected innerClassesDeclarations() '''\r
 110         «IF !enclosedGeneratedTypes.empty»\r
 111             «FOR innerClass : enclosedGeneratedTypes SEPARATOR "\n"»\r
 112                 «IF (innerClass instanceof GeneratedTransferObject)»\r
 113                     «val classTemplate = new ClassTemplate(innerClass as GeneratedTransferObject)»\r
 114                     «classTemplate.generateAsInnerClass»\r
 115                     \r
 116                 «ENDIF»\r
 117             «ENDFOR»\r
 118         «ENDIF»\r
 119     '''\r
 120     \r
 121     \r
 122     def protected constructors() '''\r
 123     «allValuesConstructor»\r
 124     «IF !allProperties.empty»\r
 125     «copyConstructor»\r
 126     «ENDIF»\r
 127     «IF properties.empty && !parentProperties.empty »\r
 128         «parentConstructor»\r
 129     «ENDIF»\r
 130     '''\r
 131     \r
 132     def protected allValuesConstructor() '''\r
 133     public «type.name»(«allProperties.asArgumentsDeclaration») {\r
 134         «IF false == parentProperties.empty»\r
 135             super(«parentProperties.asArguments»);\r
 136         «ENDIF»\r
 137         «FOR p : properties» \r
 138             this.«p.fieldName» = «p.fieldName»;\r
 139         «ENDFOR»\r
 140     }\r
 141     '''\r
 142     \r
 143     \r
 144     def protected copyConstructor() '''\r
 145     /**\r
 146      * Creates a copy from Source Object.\r
 147      *\r
 148      * @param source Source object\r
 149      */\r
 150     public «type.name»(«type.name» source) {\r
 151         «IF false == parentProperties.empty»\r
 152             super(source);\r
 153         «ENDIF»\r
 154         «FOR p : properties» \r
 155             this.«p.fieldName» = source.«p.fieldName»;\r
 156         «ENDFOR»\r
 157     }\r
 158     '''\r
 159     \r
 160     def protected parentConstructor() '''\r
 161     /**\r
 162      * Creates a new instance from «genTO.superType.importedName»\r
 163      *\r
 164      * @param source Source object\r
 165      */\r
 166     public «type.name»(«genTO.superType.importedName» source) {\r
 167             super(source);\r
 168     }\r
 169     '''\r
 170     \r
 171 \r
 172     \r
 173     /**\r
 174      * Template method which generates JAVA class declaration.\r
 175      * \r
 176      * @param isInnerClass boolean value which specify if generated class is|isn't inner\r
 177      * @return string with class declaration in JAVA format\r
 178      */\r
 179     def protected generateClassDeclaration(boolean isInnerClass) '''\r
 180         public«\r
 181         IF (isInnerClass)»«\r
 182             " static final "»«\r
 183         ELSEIF (type.abstract)»«\r
 184             " abstract "»«\r
 185         ELSE»«\r
 186             " "»«\r
 187         ENDIF»class «type.name»«\r
 188         IF (genTO.superType != null)»«\r
 189             " extends "»«genTO.superType.importedName»«\r
 190         ENDIF»\r
 191         «IF (!type.implements.empty)»«\r
 192             " implements "»«\r
 193             FOR type : type.implements SEPARATOR ", "»«\r
 194                 type.importedName»«\r
 195             ENDFOR»«\r
 196         ENDIF\r
 197     »'''\r
 198     \r
 199     /**\r
 200      * Template method which generates JAVA enum type.\r
 201      * \r
 202      * @return string with inner enum source code in JAVA format\r
 203      */\r
 204     def protected enumDeclarations() '''\r
 205         «IF !enums.empty»\r
 206             «FOR e : enums SEPARATOR "\n"»\r
 207                 «val enumTemplate = new EnumTemplate(e)»\r
 208                 «enumTemplate.generateAsInnerClass»\r
 209             «ENDFOR»\r
 210         «ENDIF»\r
 211     '''\r
 212     \r
 213     /**\r
 214      * Template method wich generates JAVA constants.\r
 215      * \r
 216      * @return string with constants in JAVA format \r
 217      */\r
 218     def protected constantsDeclarations() '''\r
 219         «IF !consts.empty»\r
 220             «FOR c : consts»\r
 221                 «IF c.name == TypeConstants.PATTERN_CONSTANT_NAME»\r
 222                     «val cValue = c.value»\r
 223                     «IF cValue instanceof List<?>»\r
 224                         «val cValues = cValue as List<?>»\r
 225                         private static final List<Pattern> «Constants.MEMBER_PATTERN_LIST» = new ArrayList<Pattern>();\r
 226                         public static final List<String> «TypeConstants.PATTERN_CONSTANT_NAME» = Arrays.asList(«\r
 227                         FOR v : cValues SEPARATOR ", "»«\r
 228                             IF v instanceof String»"«\r
 229                                 v as String»"«\r
 230                             ENDIF»«\r
 231                         ENDFOR»);\r
 232                         \r
 233                         «generateStaticInicializationBlock»\r
 234                     «ENDIF»\r
 235                 «ELSE»\r
 236                     public static final «c.type.importedName» «c.name» = «c.value»;\r
 237                 «ENDIF»\r
 238             «ENDFOR»\r
 239         «ENDIF»\r
 240     '''\r
 241     \r
 242     /**\r
 243      * Template method which generates JAVA static initialization block.\r
 244      * \r
 245      * @return string with static initialization block in JAVA format\r
 246      */\r
 247     def protected generateStaticInicializationBlock() '''\r
 248         static {\r
 249             for (String regEx : «TypeConstants.PATTERN_CONSTANT_NAME») {\r
 250                 «Constants.MEMBER_PATTERN_LIST».add(Pattern.compile(regEx));\r
 251             }\r
 252         }\r
 253     '''\r
 254     \r
 255     /**\r
 256      * Template method which generates JAVA class attributes.\r
 257      * \r
 258      * @return string with the class attributes in JAVA format\r
 259      */\r
 260     def protected generateFields() '''\r
 261         «IF !properties.empty»\r
 262             «FOR f : properties»\r
 263                 «IF f.readOnly»final«ENDIF» private «f.returnType.importedName» «f.fieldName»;\r
 264             «ENDFOR»\r
 265         «ENDIF»\r
 266     '''\r
 267     \r
 268 \r
 269     /**\r
 270      * Template method which generates the method <code>hashCode()</code>.\r
 271      * \r
 272      * @return string with the <code>hashCode()</code> method definition in JAVA format\r
 273      */\r
 274     def protected generateHashCode() '''\r
 275         «IF !genTO.hashCodeIdentifiers.empty»\r
 276             @Override\r
 277             public int hashCode() {\r
 278                 final int prime = 31;\r
 279                 int result = 1;\r
 280                 «FOR property : genTO.hashCodeIdentifiers»\r
 281                     result = prime * result + ((«property.fieldName» == null) ? 0 : «property.fieldName».hashCode());\r
 282                 «ENDFOR»\r
 283                 return result;\r
 284             }\r
 285         «ENDIF»\r
 286     '''\r
 287     \r
 288     /**\r
 289      * Template method which generates the method <code>equals()</code>.\r
 290      * \r
 291      * @return string with the <code>equals()</code> method definition in JAVA format     \r
 292      */\r
 293     def protected generateEquals() '''\r
 294         «IF !genTO.equalsIdentifiers.empty»\r
 295             @Override\r
 296             public boolean equals(java.lang.Object obj) {\r
 297                 if (this == obj) {\r
 298                     return true;\r
 299                 }\r
 300                 if (obj == null) {\r
 301                     return false;\r
 302                 }\r
 303                 if (getClass() != obj.getClass()) {\r
 304                     return false;\r
 305                 }\r
 306                 «type.name» other = («type.name») obj;\r
 307                 «FOR property : genTO.equalsIdentifiers»\r
 308                     «val fieldName = property.fieldName»\r
 309                     if («fieldName» == null) {\r
 310                         if (other.«fieldName» != null) {\r
 311                             return false;\r
 312                         }\r
 313                     } else if(!«fieldName».equals(other.«fieldName»)) {\r
 314                         return false;\r
 315                     }\r
 316                 «ENDFOR»\r
 317                 return true;\r
 318             }\r
 319         «ENDIF»\r
 320     '''\r
 321     \r
 322     /**\r
 323      * Template method which generates the method <code>toString()</code>.\r
 324      * \r
 325      * @return string with the <code>toString()</code> method definition in JAVA format     \r
 326      */\r
 327     def protected generateToString() '''\r
 328         «IF !genTO.toStringIdentifiers.empty»\r
 329             @Override\r
 330             public String toString() {\r
 331                 StringBuilder builder = new StringBuilder();\r
 332                 «val properties = genTO.toStringIdentifiers»\r
 333                 builder.append("«type.name» [«properties.get(0).fieldName»=");\r
 334                 «IF properties.get(0).returnType.name.contains("[")»\r
 335                     builder.append(java.util.Arrays.toString(«properties.get(0).fieldName»));\r
 336                 «ELSE»\r
 337                     builder.append(«properties.get(0).fieldName»);\r
 338                 «ENDIF»\r
 339                 builder.append(«properties.get(0).fieldName»);\r
 340                 «FOR i : 1..<genTO.toStringIdentifiers.size»\r
 341                     builder.append(", «properties.get(i).fieldName»=");\r
 342                     «IF properties.get(i).returnType.name.contains("[")»\r
 343                         builder.append(java.util.Arrays.toString(«properties.get(i).fieldName»));\r
 344                     «ELSE»\r
 345                         builder.append(«properties.get(i).fieldName»);\r
 346                     «ENDIF»\r
 347                 «ENDFOR»\r
 348                 builder.append("]");\r
 349                 return builder.toString();\r
 350             }\r
 351         «ENDIF»\r
 352     '''\r
 353     \r
 354 }\r