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