code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/BindingGeneratorImpl.xtend

   1 /*\r
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 package org.opendaylight.yangtools.sal.binding.generator.impl;\r
   9 \r
  10 import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.*;\r
  11 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.*;\r
  12 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*;\r
  13 \r
  14 import java.util.ArrayList;\r
  15 import java.util.Collections;\r
  16 import java.util.HashMap;\r
  17 import java.util.List;\r
  18 import java.util.Map;\r
  19 import java.util.Set;\r
  20 \r
  21 import org.opendaylight.yangtools.binding.generator.util.BindingTypes;\r
  22 import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;\r
  23 import org.opendaylight.yangtools.binding.generator.util.Types;\r
  24 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;\r
  25 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;\r
  26 import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;\r
  27 import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;\r
  28 import org.opendaylight.yangtools.sal.binding.model.api.AccessModifier;\r
  29 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;\r
  30 import org.opendaylight.yangtools.sal.binding.model.api.Type;\r
  31 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;\r
  32 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;\r
  33 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;\r
  34 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;\r
  35 import org.opendaylight.yangtools.sal.binding.yang.types.GroupingDefinitionDependencySort;\r
  36 import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl;\r
  37 import org.opendaylight.yangtools.yang.binding.RpcService;\r
  38 import org.opendaylight.yangtools.yang.common.RpcResult;\r
  39 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;\r
  40 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;\r
  41 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;\r
  42 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;\r
  43 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;\r
  44 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;\r
  45 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;\r
  46 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;\r
  47 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;\r
  48 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;\r
  49 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;\r
  50 import org.opendaylight.yangtools.yang.model.api.Module;\r
  51 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;\r
  52 import org.opendaylight.yangtools.yang.model.api.SchemaContext;\r
  53 import org.opendaylight.yangtools.yang.model.api.SchemaNode;\r
  54 import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
  55 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;\r
  56 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;\r
  57 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;\r
  58 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;\r
  59 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;\r
  60 import org.opendaylight.yangtools.yang.model.util.DataNodeIterator;\r
  61 import org.opendaylight.yangtools.yang.model.util.ExtendedType;\r
  62 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;\r
  63 import org.opendaylight.yangtools.yang.model.util.UnionType;\r
  64 import static com.google.common.base.Preconditions.*;\r
  65 import static extension org.opendaylight.yangtools.binding.generator.util.Types.*;\r
  66 \r
  67 public class BindingGeneratorImpl implements BindingGenerator {\r
  68 \r
  69     /**\r
  70      * Outter key represents the package name. Outter value represents map of\r
  71      * all builders in the same package. Inner key represents the schema node\r
  72      * name (in JAVA class/interface name format). Inner value represents\r
  73      * instance of builder for schema node specified in key part.\r
  74      */\r
  75     private Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders;\r
  76 \r
  77     /**\r
  78      * Provide methods for converting YANG types to JAVA types.\r
  79      */\r
  80     private var TypeProvider typeProvider;\r
  81 \r
  82     /**\r
  83      * Holds reference to schema context to resolve data of augmented elemnt\r
  84      * when creating augmentation builder\r
  85      */\r
  86     private var SchemaContext schemaContext;\r
  87 \r
  88     /**\r
  89      * Each grouping which is converted from schema node to generated type is\r
  90      * added to this map with its Schema path as key to make it easier to get\r
  91      * reference to it. In schema nodes in <code>uses</code> attribute there is\r
  92      * only Schema Path but when building list of implemented interfaces for\r
  93      * Schema node the object of type <code>Type</code> is required. So in this\r
  94      * case is used this map.\r
  95      */\r
  96     private val allGroupings = new HashMap<SchemaPath, GeneratedType>();\r
  97     \r
  98     \r
  99     private val yangToJavaMapping = new HashMap<SchemaPath, Type>();\r
 100 \r
 101     /**\r
 102      * Constant with the concrete name of namespace.\r
 103      */\r
 104     private val static String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";\r
 105 \r
 106     /**\r
 107      * Constant with the concrete name of identifier.\r
 108      */\r
 109     private val static String AUGMENT_IDENTIFIER_NAME = "augment-identifier";\r
 110 \r
 111     \r
 112     /**\r
 113      * Resolves generated types from <code>context</code> schema nodes of all\r
 114      * modules.\r
 115      *\r
 116      * Generated types are created for modules, groupings, types, containers,\r
 117      * lists, choices, augments, rpcs, notification, identities.\r
 118      *\r
 119      * @param context\r
 120      *            schema context which contains data about all schema nodes\r
 121      *            saved in modules\r
 122      * @return list of types (usually <code>GeneratedType</code>\r
 123      *         <code>GeneratedTransferObject</code>which are generated from\r
 124      *         <code>context</code> data.\r
 125      * @throws IllegalArgumentException\r
 126      *             if param <code>context</code> is null\r
 127      * @throws IllegalStateException\r
 128      *             if <code>context</code> contain no modules\r
 129      */\r
 130     override generateTypes(SchemaContext context) {\r
 131         checkArgument(context !== null,"Schema Context reference cannot be NULL.");\r
 132         checkState(context.modules !== null,"Schema Context does not contain defined modules.");\r
 133         val List<Type> generatedTypes = new ArrayList();\r
 134         schemaContext = context;\r
 135         typeProvider = new TypeProviderImpl(context);\r
 136         val Set<Module> modules = context.modules;\r
 137         genTypeBuilders = new HashMap();\r
 138         for (module : modules) {\r
 139 \r
 140             generatedTypes.addAll(allGroupingsToGenTypes(module));\r
 141 \r
 142             if (false == module.childNodes.isEmpty()) {\r
 143                 generatedTypes.add(moduleToDataType(module));\r
 144             }\r
 145             generatedTypes.addAll(allTypeDefinitionsToGenTypes(module));\r
 146             generatedTypes.addAll(allContainersToGenTypes(module));\r
 147             generatedTypes.addAll(allListsToGenTypes(module));\r
 148             generatedTypes.addAll(allChoicesToGenTypes(module));\r
 149             generatedTypes.addAll(allRPCMethodsToGenType(module));\r
 150             generatedTypes.addAll(allNotificationsToGenType(module));\r
 151             generatedTypes.addAll(allIdentitiesToGenTypes(module, context));\r
 152         }\r
 153         for (module : modules) {\r
 154             generatedTypes.addAll(allAugmentsToGenTypes(module));\r
 155             \r
 156         }\r
 157         return generatedTypes;\r
 158     }\r
 159 \r
 160     /**\r
 161      * Resolves generated types from <code>context</code> schema nodes only for\r
 162      * modules specified in <code>modules</code>\r
 163      *\r
 164      * Generated types are created for modules, groupings, types, containers,\r
 165      * lists, choices, augments, rpcs, notification, identities.\r
 166      *\r
 167      * @param context\r
 168      *            schema context which contains data about all schema nodes\r
 169      *            saved in modules\r
 170      * @param modules\r
 171      *            set of modules for which schema nodes should be generated\r
 172      *            types\r
 173      * @return list of types (usually <code>GeneratedType</code> or\r
 174      *         <code>GeneratedTransferObject</code>) which:\r
 175      *         <ul>\r
 176      *         <li>are generated from <code>context</code> schema nodes and</li>\r
 177      *         <li>are also part of some of the module in <code>modules</code>\r
 178      *         set</li>.\r
 179      *         </ul>\r
 180      * @throws IllegalArgumentException\r
 181      *             <ul>\r
 182      *             <li>if param <code>context</code> is null or</li>\r
 183      *             <li>if param <code>modules</code> is null</li>\r
 184      *             </ul>\r
 185      * @throws IllegalStateException\r
 186      *             if <code>context</code> contain no modules\r
 187      */\r
 188     override generateTypes(SchemaContext context, Set<Module> modules) {\r
 189         checkArgument(context !== null,"Schema Context reference cannot be NULL.");\r
 190         checkState(context.modules !== null,"Schema Context does not contain defined modules.");\r
 191         checkArgument(modules !== null,"Set of Modules cannot be NULL.");\r
 192 \r
 193         val List<Type> filteredGenTypes = new ArrayList();\r
 194         schemaContext = context;\r
 195         typeProvider = new TypeProviderImpl(context);\r
 196         val Set<Module> contextModules = context.modules;\r
 197         genTypeBuilders = new HashMap();\r
 198         \r
 199         for (contextModule : contextModules) {\r
 200             val List<Type> generatedTypes = new ArrayList();\r
 201 \r
 202             generatedTypes.addAll(allGroupingsToGenTypes(contextModule));\r
 203             if (false == contextModule.childNodes.isEmpty()) {\r
 204                 generatedTypes.add(moduleToDataType(contextModule));\r
 205             }\r
 206             generatedTypes.addAll(allTypeDefinitionsToGenTypes(contextModule));\r
 207             generatedTypes.addAll(allContainersToGenTypes(contextModule));\r
 208             generatedTypes.addAll(allListsToGenTypes(contextModule));\r
 209             generatedTypes.addAll(allChoicesToGenTypes(contextModule));\r
 210             generatedTypes.addAll(allRPCMethodsToGenType(contextModule));\r
 211             generatedTypes.addAll(allNotificationsToGenType(contextModule));\r
 212             generatedTypes.addAll(allIdentitiesToGenTypes(contextModule, context));\r
 213             \r
 214             if (modules.contains(contextModule)) {\r
 215                 filteredGenTypes.addAll(generatedTypes);\r
 216             }\r
 217         }\r
 218         for (contextModule : contextModules) {\r
 219             val generatedTypes = (allAugmentsToGenTypes(contextModule));\r
 220             if (modules.contains(contextModule)) {\r
 221                 filteredGenTypes.addAll(generatedTypes);\r
 222             }\r
 223             \r
 224         }\r
 225         return filteredGenTypes;\r
 226     }\r
 227 \r
 228     /**\r
 229      * Converts all extended type definitions of module to the list of\r
 230      * <code>Type</code> objects.\r
 231      *\r
 232      * @param module\r
 233      *            module from which is obtained set of type definitions\r
 234      * @return list of <code>Type</code> which are generated from extended\r
 235      *         definition types (object of type <code>ExtendedType</code>)\r
 236      * @throws IllegalArgumentException\r
 237      *             <ul>\r
 238      *             <li>if module equals null</li>\r
 239      *             <li>if name of module equals null</li>\r
 240      *             <li>if type definitions of module equal null</li>\r
 241      *             </ul>\r
 242      *\r
 243      */\r
 244     private def List<Type> allTypeDefinitionsToGenTypes( Module module) {\r
 245         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 246         checkArgument(module.name !== null,"Module name cannot be NULL.");\r
 247         val Set<TypeDefinition<?>> typeDefinitions = module.typeDefinitions;\r
 248         checkState(typeDefinitions !== null,'''Type Definitions for module «module.name» cannot be NULL.''');\r
 249 \r
 250         \r
 251         val List<Type> generatedTypes = new ArrayList();\r
 252         for ( TypeDefinition<?> typedef : typeDefinitions) {\r
 253             if (typedef !== null) {\r
 254                 val type = (typeProvider as TypeProviderImpl).generatedTypeForExtendedDefinitionType(typedef, typedef);\r
 255                 if ((type !== null) && !generatedTypes.contains(type)) {\r
 256                     generatedTypes.add(type);\r
 257                 }\r
 258             }\r
 259         }\r
 260         return generatedTypes;\r
 261     }\r
 262 \r
 263     /**\r
 264      * Converts all <b>containers</b> of the module to the list of\r
 265      * <code>Type</code> objects.\r
 266      *\r
 267      * @param module\r
 268      *            module from which is obtained DataNodeIterator to iterate over\r
 269      *            all containers\r
 270      * @return list of <code>Type</code> which are generated from containers\r
 271      *         (objects of type <code>ContainerSchemaNode</code>)\r
 272      * @throws IllegalArgumentException\r
 273      *             <ul>\r
 274      *             <li>if the module equals null</li>\r
 275      *             <li>if the name of module equals null</li>\r
 276      *             <li>if the set of child nodes equals null</li>\r
 277      *             </ul>\r
 278      *\r
 279      */\r
 280     private def List<Type> allContainersToGenTypes( Module module) {\r
 281         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 282 \r
 283         checkArgument(module.name !== null,"Module name cannot be NULL.");\r
 284 \r
 285         if (module.childNodes === null) {\r
 286             throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.name\r
 287                     + " cannot be NULL.");\r
 288         }\r
 289 \r
 290         val List<Type> generatedTypes = new ArrayList();\r
 291         val it = new DataNodeIterator(module);\r
 292         val List<ContainerSchemaNode> schemaContainers = it.allContainers();\r
 293         val basePackageName = moduleNamespaceToPackageName(module);\r
 294         for (container : schemaContainers) {\r
 295             if (!container.isAddedByUses()) {\r
 296                 generatedTypes.add(containerToGenType(basePackageName, container));\r
 297             }\r
 298         }\r
 299         return generatedTypes;\r
 300     }\r
 301 \r
 302     /**\r
 303      * Converts all <b>lists</b> of the module to the list of <code>Type</code>\r
 304      * objects.\r
 305      *\r
 306      * @param module\r
 307      *            module from which is obtained DataNodeIterator to iterate over\r
 308      *            all lists\r
 309      * @return list of <code>Type</code> which are generated from lists (objects\r
 310      *         of type <code>ListSchemaNode</code>)\r
 311      * @throws IllegalArgumentException\r
 312      *             <ul>\r
 313      *             <li>if the module equals null</li>\r
 314      *             <li>if the name of module equals null</li>\r
 315      *             <li>if the set of child nodes equals null</li>\r
 316      *             </ul>\r
 317      *\r
 318      */\r
 319     private def List<Type> allListsToGenTypes( Module module) {\r
 320         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 321         checkArgument(module.name !== null,"Module name cannot be NULL.");\r
 322 \r
 323         if (module.childNodes === null) {\r
 324             throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.name\r
 325                     + " cannot be NULL.");\r
 326         }\r
 327 \r
 328         val List<Type> generatedTypes = new ArrayList();\r
 329         val it = new DataNodeIterator(module);\r
 330         val List<ListSchemaNode> schemaLists = it.allLists();\r
 331         val basePackageName = moduleNamespaceToPackageName(module);\r
 332         if (schemaLists !== null) {\r
 333             for (list : schemaLists) {\r
 334                 if (!list.isAddedByUses()) {\r
 335                     generatedTypes.addAll(listToGenType(basePackageName, list));\r
 336                 }\r
 337             }\r
 338         }\r
 339         return generatedTypes;\r
 340     }\r
 341 \r
 342     /**\r
 343      * Converts all <b>choices</b> of the module to the list of\r
 344      * <code>Type</code> objects.\r
 345      *\r
 346      * @param module\r
 347      *            module from which is obtained DataNodeIterator to iterate over\r
 348      *            all choices\r
 349      * @return list of <code>Type</code> which are generated from choices\r
 350      *         (objects of type <code>ChoiceNode</code>)\r
 351      * @throws IllegalArgumentException\r
 352      *             <ul>\r
 353      *             <li>if the module equals null</li>\r
 354      *             <li>if the name of module equals null</li> *\r
 355      *             </ul>\r
 356      *\r
 357      */\r
 358     private def List<GeneratedType> allChoicesToGenTypes( Module module) {\r
 359         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 360         checkArgument(module.name !== null,"Module name cannot be NULL.");\r
 361 \r
 362         val it = new DataNodeIterator(module);\r
 363         val choiceNodes = it.allChoices();\r
 364         val basePackageName = moduleNamespaceToPackageName(module);\r
 365 \r
 366         val List<GeneratedType> generatedTypes = new ArrayList();\r
 367         for (choice : choiceNodes) {\r
 368             if ((choice !== null) && !choice.isAddedByUses()) {\r
 369                 generatedTypes.addAll(choiceToGeneratedType(basePackageName, choice));\r
 370             }\r
 371         }\r
 372         return generatedTypes;\r
 373     }\r
 374 \r
 375     /**\r
 376      * Converts all <b>augmentation</b> of the module to the list\r
 377      * <code>Type</code> objects.\r
 378      *\r
 379      * @param module\r
 380      *            module from which is obtained list of all augmentation objects\r
 381      *            to iterate over them\r
 382      * @return list of <code>Type</code> which are generated from augments\r
 383      *         (objects of type <code>AugmentationSchema</code>)\r
 384      * @throws IllegalArgumentException\r
 385      *             <ul>\r
 386      *             <li>if the module equals null</li>\r
 387      *             <li>if the name of module equals null</li>\r
 388      *             <li>if the set of child nodes equals null</li>\r
 389      *             </ul>\r
 390      *\r
 391      */\r
 392     private def List<Type> allAugmentsToGenTypes( Module module) {\r
 393         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 394         checkArgument(module.name !== null,"Module name cannot be NULL.");\r
 395         if (module.childNodes === null) {\r
 396             throw new IllegalArgumentException("Reference to Set of Augmentation Definitions in module "\r
 397                     + module.name + " cannot be NULL.");\r
 398         }\r
 399 \r
 400         val List<Type> generatedTypes = new ArrayList();\r
 401         val basePackageName = moduleNamespaceToPackageName(module);\r
 402         val List<AugmentationSchema> augmentations = resolveAugmentations(module);\r
 403         for (augment : augmentations) {\r
 404             generatedTypes.addAll(augmentationToGenTypes(basePackageName, augment));\r
 405         }\r
 406         return generatedTypes;\r
 407     }\r
 408 \r
 409     /**\r
 410      * Returns list of <code>AugmentationSchema</code> objects. The objects are\r
 411      * sorted according to the length of their target path from the shortest to\r
 412      * the longest.\r
 413      *\r
 414      * @param module\r
 415      *            module from which is obtained list of all augmentation objects\r
 416      * @return list of sorted <code>AugmentationSchema</code> objects obtained\r
 417      *         from <code>module</code>\r
 418      * @throws IllegalArgumentException\r
 419      *             <ul>\r
 420      *             <li>if the module equals null</li>\r
 421      *             <li>if the set of augmentation equals null</li>\r
 422      *             </ul>\r
 423      *\r
 424      */\r
 425     private def List<AugmentationSchema> resolveAugmentations( Module module) {\r
 426         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 427         checkState(module.augmentations !== null,"Augmentations Set cannot be NULL.");\r
 428 \r
 429         val Set<AugmentationSchema> augmentations = module.augmentations;\r
 430         val List<AugmentationSchema> sortedAugmentations = new ArrayList(augmentations);\r
 431         Collections.sort(sortedAugmentations, [augSchema1, augSchema2 |\r
 432 \r
 433                 if (augSchema1.targetPath.path.size() > augSchema2.targetPath.path.size()) {\r
 434                     return 1;\r
 435                 } else if (augSchema1.targetPath.path.size() < augSchema2.targetPath.path.size()) {\r
 436                     return -1;\r
 437                 }\r
 438                 return 0;\r
 439            ]);\r
 440         return sortedAugmentations;\r
 441     }\r
 442 \r
 443     /**\r
 444      * Converts whole <b>module</b> to <code>GeneratedType</code> object.\r
 445      * Firstly is created the module builder object from which is vally\r
 446      * obtained reference to <code>GeneratedType</code> object.\r
 447      *\r
 448      * @param module\r
 449      *            module from which are obtained the module name, child nodes,\r
 450      *            uses and is derived package name\r
 451      * @return <code>GeneratedType</code> which is internal representation of\r
 452      *         the module\r
 453      * @throws IllegalArgumentException\r
 454      *             if the module equals null\r
 455      *\r
 456      */\r
 457     private def GeneratedType moduleToDataType( Module module) {\r
 458         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 459 \r
 460         val moduleDataTypeBuilder = moduleTypeBuilder(module, "Data");\r
 461         addImplementedInterfaceFromUses(module, moduleDataTypeBuilder);\r
 462         moduleDataTypeBuilder.addImplementsType(DATA_ROOT);\r
 463 \r
 464         val basePackageName = moduleNamespaceToPackageName(module);\r
 465         if (moduleDataTypeBuilder !== null) {\r
 466             val Set<DataSchemaNode> dataNodes = module.childNodes;\r
 467             resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, dataNodes);\r
 468         }\r
 469         return moduleDataTypeBuilder.toInstance();\r
 470     }\r
 471 \r
 472     /**\r
 473      * Converts all <b>rpcs</b> inputs and outputs substatements of the module\r
 474      * to the list of <code>Type</code> objects. In addition are to containers\r
 475      * and lists which belong to input or output also part of returning list.\r
 476      *\r
 477      * @param module\r
 478      *            module from which is obtained set of all rpc objects to\r
 479      *            iterate over them\r
 480      * @return list of <code>Type</code> which are generated from rpcs inputs,\r
 481      *         outputs + container and lists which are part of inputs or outputs\r
 482      * @throws IllegalArgumentException\r
 483      *             <ul>\r
 484      *             <li>if the module equals null</li>\r
 485      *             <li>if the name of module equals null</li>\r
 486      *             <li>if the set of child nodes equals null</li>\r
 487      *             </ul>\r
 488      *\r
 489      */\r
 490     private def List<Type> allRPCMethodsToGenType( Module module) {\r
 491         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 492 \r
 493         checkArgument(module.name !== null,"Module name cannot be NULL.");\r
 494 \r
 495         if (module.childNodes === null) {\r
 496             throw new IllegalArgumentException("Reference to Set of RPC Method Definitions in module "\r
 497                     + module.name + " cannot be NULL.");\r
 498         }\r
 499 \r
 500         val basePackageName = moduleNamespaceToPackageName(module);\r
 501         val Set<RpcDefinition> rpcDefinitions = module.rpcs;\r
 502 \r
 503         if (rpcDefinitions.isEmpty()) {\r
 504             return Collections.emptyList();\r
 505         }\r
 506 \r
 507         val List<Type> genRPCTypes = new ArrayList();\r
 508         val interfaceBuilder = moduleTypeBuilder(module, "Service");\r
 509         interfaceBuilder.addImplementsType(Types.typeForClass(RpcService));\r
 510         for (rpc : rpcDefinitions) {\r
 511             if (rpc !== null) {\r
 512 \r
 513                 val rpcName = parseToClassName(rpc.QName.localName);\r
 514                 val rpcMethodName = parseToValidParamName(rpcName);\r
 515                 val method = interfaceBuilder.addMethod(rpcMethodName);\r
 516 \r
 517                 val rpcInOut = new ArrayList();\r
 518 \r
 519                 val input = rpc.input;\r
 520                 val output = rpc.output;\r
 521 \r
 522                 if (input !== null) {\r
 523                     rpcInOut.add(new DataNodeIterator(input));\r
 524                     val inType = addRawInterfaceDefinition(basePackageName, input, rpcName);\r
 525                     addImplementedInterfaceFromUses(input, inType);\r
 526                     inType.addImplementsType(DATA_OBJECT);\r
 527                     inType.addImplementsType(augmentable(inType));\r
 528                     resolveDataSchemaNodes(basePackageName, inType, input.childNodes);\r
 529                     val inTypeInstance = inType.toInstance();\r
 530                     genRPCTypes.add(inTypeInstance);\r
 531                     method.addParameter(inTypeInstance, "input");\r
 532                 }\r
 533 \r
 534                 var Type outTypeInstance = VOID;\r
 535                 if (output !== null) {\r
 536                     rpcInOut.add(new DataNodeIterator(output));\r
 537                     val outType = addRawInterfaceDefinition(basePackageName, output, rpcName);\r
 538                     addImplementedInterfaceFromUses(output, outType);\r
 539                     outType.addImplementsType(DATA_OBJECT);\r
 540                     outType.addImplementsType(augmentable(outType));\r
 541 \r
 542                     resolveDataSchemaNodes(basePackageName, outType, output.childNodes);\r
 543                     outTypeInstance = outType.toInstance();\r
 544                     genRPCTypes.add(outTypeInstance);\r
 545 \r
 546                 }\r
 547 \r
 548                 val rpcRes = Types.parameterizedTypeFor(Types.typeForClass(RpcResult), outTypeInstance);\r
 549                 method.setReturnType(Types.parameterizedTypeFor(FUTURE, rpcRes));\r
 550                 for (iter : rpcInOut) {\r
 551                     val List<ContainerSchemaNode> nContainers = iter.allContainers();\r
 552                     if ((nContainers !== null) && !nContainers.isEmpty()) {\r
 553                         for (container : nContainers) {\r
 554                             if (!container.isAddedByUses()) {\r
 555                                 genRPCTypes.add(containerToGenType(basePackageName, container));\r
 556                             }\r
 557                         }\r
 558                     }\r
 559                     val List<ListSchemaNode> nLists = iter.allLists();\r
 560                     if ((nLists !== null) && !nLists.isEmpty()) {\r
 561                         for (list : nLists) {\r
 562                             if (!list.isAddedByUses()) {\r
 563                                 genRPCTypes.addAll(listToGenType(basePackageName, list));\r
 564                             }\r
 565                         }\r
 566                     }\r
 567                 }\r
 568             }\r
 569         }\r
 570         genRPCTypes.add(interfaceBuilder.toInstance());\r
 571         return genRPCTypes;\r
 572     }\r
 573 \r
 574     /**\r
 575      * Converts all <b>notifications</b> of the module to the list of\r
 576      * <code>Type</code> objects. In addition are to this list added containers\r
 577      * and lists which are part of this notification.\r
 578      *\r
 579      * @param module\r
 580      *            module from which is obtained set of all notification objects\r
 581      *            to iterate over them\r
 582      * @return list of <code>Type</code> which are generated from notification\r
 583      *         (object of type <code>NotificationDefinition</code>\r
 584      * @throws IllegalArgumentException\r
 585      *             <ul>\r
 586      *             <li>if the module equals null</li>\r
 587      *             <li>if the name of module equals null</li>\r
 588      *             <li>if the set of child nodes equals null</li>\r
 589      *             </ul>\r
 590      *\r
 591      */\r
 592     private def List<Type> allNotificationsToGenType( Module module) {\r
 593         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 594 \r
 595         checkArgument(module.name !== null,"Module name cannot be NULL.");\r
 596 \r
 597         if (module.childNodes === null) {\r
 598             throw new IllegalArgumentException("Reference to Set of Notification Definitions in module "\r
 599                     + module.name + " cannot be NULL.");\r
 600         }\r
 601         val notifications = module.notifications;\r
 602         if(notifications.isEmpty()) return Collections.emptyList();\r
 603         \r
 604         val listenerInterface = moduleTypeBuilder(module, "Listener");\r
 605         listenerInterface.addImplementsType(BindingTypes.NOTIFICATION_LISTENER);\r
 606         \r
 607         \r
 608         \r
 609         val basePackageName = moduleNamespaceToPackageName(module);\r
 610         val List<Type> generatedTypes = new ArrayList();\r
 611         \r
 612         \r
 613         for ( notification : notifications) {\r
 614             if (notification !== null) {\r
 615                 val iter = new DataNodeIterator(notification);\r
 616 \r
 617                 // Containers\r
 618                 for (node : iter.allContainers()) {\r
 619                     if (!node.isAddedByUses()) {\r
 620                         generatedTypes.add(containerToGenType(basePackageName, node));\r
 621                     }\r
 622                 }\r
 623                 // Lists\r
 624                 for (node : iter.allLists()) {\r
 625                     if (!node.isAddedByUses()) {\r
 626                         generatedTypes.addAll(listToGenType(basePackageName, node));\r
 627                     }\r
 628                 }\r
 629                 val notificationInterface = addDefaultInterfaceDefinition(basePackageName,\r
 630                         notification);\r
 631                 notificationInterface.addImplementsType(NOTIFICATION);\r
 632                 // Notification object\r
 633                 resolveDataSchemaNodes(basePackageName, notificationInterface, notification.childNodes);\r
 634                 \r
 635                 listenerInterface.addMethod("on"+notificationInterface.name) //\r
 636                     .setAccessModifier(AccessModifier.PUBLIC)\r
 637                     .addParameter(notificationInterface, "notification")\r
 638                     .setReturnType(Types.VOID);\r
 639                 \r
 640                 generatedTypes.add(notificationInterface.toInstance());\r
 641             }\r
 642         }\r
 643         generatedTypes.add(listenerInterface.toInstance());\r
 644         return generatedTypes;\r
 645     }\r
 646 \r
 647     /**\r
 648      * Converts all <b>identities</b> of the module to the list of\r
 649      * <code>Type</code> objects.\r
 650      *\r
 651      * @param module\r
 652      *            module from which is obtained set of all identity objects to\r
 653      *            iterate over them\r
 654      * @param context\r
 655      *            schema context only used as input parameter for method\r
 656      *            {@link identityToGenType}\r
 657      * @return list of <code>Type</code> which are generated from identities\r
 658      *         (object of type <code>IdentitySchemaNode</code>\r
 659      *\r
 660      */\r
 661     private def List<Type> allIdentitiesToGenTypes( Module module, SchemaContext context) {\r
 662         val List<Type> genTypes = new ArrayList();\r
 663 \r
 664         val Set<IdentitySchemaNode> schemaIdentities = module.identities;\r
 665 \r
 666         val basePackageName = moduleNamespaceToPackageName(module);\r
 667 \r
 668         if (schemaIdentities !== null && !schemaIdentities.isEmpty()) {\r
 669             for (identity : schemaIdentities) {\r
 670                 genTypes.add(identityToGenType(basePackageName, identity, context));\r
 671             }\r
 672         }\r
 673         return genTypes;\r
 674     }\r
 675 \r
 676     /**\r
 677      * Converts the <b>identity</b> object to GeneratedType. Firstly it is\r
 678      * created transport object builder. If identity contains base identity then\r
 679      * reference to base identity is added to superior identity as its extend.\r
 680      * If identity doesn't contain base identity then only reference to abstract\r
 681      * class {@link org.opendaylight.yangtools.yang.model.api.BaseIdentity\r
 682      * BaseIdentity} is added\r
 683      *\r
 684      * @param basePackageName\r
 685      *            string contains the module package name\r
 686      * @param identity\r
 687      *            IdentitySchemaNode which contains data about identity\r
 688      * @param context\r
 689      *            SchemaContext which is used to get package and name\r
 690      *            information about base of identity\r
 691      *\r
 692      * @return GeneratedType which is generated from identity (object of type\r
 693      *         <code>IdentitySchemaNode</code>\r
 694      *\r
 695      */\r
 696     private def GeneratedType identityToGenType(String basePackageName, IdentitySchemaNode identity,\r
 697             SchemaContext context) {\r
 698         if (identity === null) {\r
 699             return null;\r
 700         }\r
 701 \r
 702         val packageName = packageNameForGeneratedType(basePackageName, identity.path);\r
 703         val genTypeName = parseToClassName(identity.QName.localName);\r
 704         val newType = new GeneratedTOBuilderImpl(packageName, genTypeName);\r
 705 \r
 706         val baseIdentity = identity.baseIdentity;\r
 707         if (baseIdentity !== null) {\r
 708             val baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);\r
 709 \r
 710             val returnTypePkgName = moduleNamespaceToPackageName(baseIdentityParentModule);\r
 711             val returnTypeName = parseToClassName(baseIdentity.QName.localName);\r
 712 \r
 713             val gto = new GeneratedTOBuilderImpl(returnTypePkgName, returnTypeName).toInstance();\r
 714             newType.setExtendsType(gto);\r
 715         } else {\r
 716             newType.setExtendsType(Types.baseIdentityTO);\r
 717         }\r
 718         newType.setAbstract(true);\r
 719         return newType.toInstance();\r
 720     }\r
 721 \r
 722     /**\r
 723      * Converts all <b>groupings</b> of the module to the list of\r
 724      * <code>Type</code> objects. Firstly are groupings sorted according mutual\r
 725      * dependencies. At least dependend (indepedent) groupings are in the list\r
 726      * saved at first positions. For every grouping the record is added to map\r
 727      * {@link BindingGeneratorImpl#allGroupings allGroupings}\r
 728      *\r
 729      * @param module\r
 730      *            module from which is obtained set of all grouping objects to\r
 731      *            iterate over them\r
 732      * @return list of <code>Type</code> which are generated from groupings\r
 733      *         (object of type <code>GroupingDefinition</code>)\r
 734      *\r
 735      */\r
 736     private def List<Type> allGroupingsToGenTypes( Module module) {\r
 737         checkArgument(module !== null,"Module parameter can not be null");\r
 738         val List<Type> genTypes = new ArrayList();\r
 739         val basePackageName = moduleNamespaceToPackageName(module);\r
 740         val Set<GroupingDefinition> groupings = module.groupings;\r
 741         val List<GroupingDefinition> groupingsSortedByDependencies = GroupingDefinitionDependencySort.sort(groupings);\r
 742 \r
 743         for (grouping : groupingsSortedByDependencies) {\r
 744             val genType = groupingToGenType(basePackageName, grouping);\r
 745             genTypes.add(genType);\r
 746             val schemaPath = grouping.path;\r
 747             allGroupings.put(schemaPath, genType);\r
 748         }\r
 749         return genTypes;\r
 750     }\r
 751 \r
 752     /**\r
 753      * Converts individual grouping to GeneratedType. Firstly generated type\r
 754      * builder is created and every child node of grouping is resolved to the\r
 755      * method.\r
 756      *\r
 757      * @param basePackageName\r
 758      *            string contains the module package name\r
 759      * @param grouping\r
 760      *            GroupingDefinition which contains data about grouping\r
 761      * @return GeneratedType which is generated from grouping (object of type\r
 762      *         <code>GroupingDefinition</code>)\r
 763      */\r
 764     private def GeneratedType groupingToGenType( String basePackageName, GroupingDefinition grouping) {\r
 765         if (grouping === null) {\r
 766             return null;\r
 767         }\r
 768 \r
 769         val packageName = packageNameForGeneratedType(basePackageName, grouping.path);\r
 770         val Set<DataSchemaNode> schemaNodes = grouping.childNodes;\r
 771         val typeBuilder = addDefaultInterfaceDefinition(packageName, grouping);\r
 772 \r
 773         resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
 774         return typeBuilder.toInstance();\r
 775     }\r
 776 \r
 777     /**\r
 778      * Tries to find EnumTypeDefinition in <code>typeDefinition</code>. If base\r
 779      * type of <code>typeDefinition</code> is of the type ExtendedType then this\r
 780      * method is recursivelly called with this base type.\r
 781      *\r
 782      * @param typeDefinition\r
 783      *            TypeDefinition in which should be EnumTypeDefinition found as\r
 784      *            base type\r
 785      * @return EnumTypeDefinition if it is found inside\r
 786      *         <code>typeDefinition</code> or <code>null</code> in other case\r
 787      */\r
 788     private def EnumTypeDefinition enumTypeDefFromExtendedType( TypeDefinition<?> typeDefinition) {\r
 789         if (typeDefinition !== null) {\r
 790             if (typeDefinition.baseType instanceof EnumTypeDefinition) {\r
 791                 return typeDefinition.baseType as EnumTypeDefinition;\r
 792             } else if (typeDefinition.baseType instanceof ExtendedType) {\r
 793                 return enumTypeDefFromExtendedType(typeDefinition.baseType);\r
 794             }\r
 795         }\r
 796         return null;\r
 797     }\r
 798 \r
 799     /**\r
 800      * Adds enumeration builder created from <code>enumTypeDef</code> to\r
 801      * <code>typeBuilder</code>.\r
 802      *\r
 803      * Each <code>enumTypeDef</code> item is added to builder with its name and\r
 804      * value.\r
 805      *\r
 806      * @param enumTypeDef\r
 807      *            EnumTypeDefinition contains enum data\r
 808      * @param enumName\r
 809      *            string contains name which will be assigned to enumeration\r
 810      *            builder\r
 811      * @param typeBuilder\r
 812      *            GeneratedTypeBuilder to which will be enum builder assigned\r
 813      * @return enumeration builder which contais data from\r
 814      *         <code>enumTypeDef</code>\r
 815      */\r
 816     private def EnumBuilder resolveInnerEnumFromTypeDefinition( EnumTypeDefinition enumTypeDef, String enumName,\r
 817             GeneratedTypeBuilder typeBuilder) {\r
 818         if ((enumTypeDef !== null) && (typeBuilder !== null) && (enumTypeDef.QName !== null)\r
 819                 && (enumTypeDef.QName.localName !== null)) {\r
 820 \r
 821             val enumerationName = parseToClassName(enumName);\r
 822             val enumBuilder = typeBuilder.addEnumeration(enumerationName);\r
 823             enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);\r
 824 \r
 825             return enumBuilder;\r
 826         }\r
 827         return null;\r
 828     }\r
 829 \r
 830     /**\r
 831      * Generates type builder for <code>module</code>.\r
 832      *\r
 833      * @param module\r
 834      *            Module which is source of package name for generated type\r
 835      *            builder\r
 836      * @param postfix\r
 837      *            string which is added to the module class name representation\r
 838      *            as suffix\r
 839      * @return instance of GeneratedTypeBuilder which represents\r
 840      *         <code>module</code>.\r
 841      * @throws IllegalArgumentException\r
 842      *             if <code>module</code> equals null\r
 843      */\r
 844     private def GeneratedTypeBuilder moduleTypeBuilder( Module module, String postfix) {\r
 845         checkArgument(module !== null,"Module reference cannot be NULL.");\r
 846         val packageName = moduleNamespaceToPackageName(module);\r
 847         val moduleName = parseToClassName(module.name) + postfix;\r
 848 \r
 849         return new GeneratedTypeBuilderImpl(packageName, moduleName);\r
 850 \r
 851     }\r
 852 \r
 853     /**\r
 854      * Converts <code>augSchema</code> to list of <code>Type</code> which\r
 855      * contains generated type for augmentation. In addition there are also\r
 856      * generated types for all containers, list and choices which are child of\r
 857      * <code>augSchema</code> node or a generated types for cases are added if\r
 858      * augmented node is choice.\r
 859      *\r
 860      * @param augmentPackageName\r
 861      *            string with the name of the package to which the augmentation\r
 862      *            belongs\r
 863      * @param augSchema\r
 864      *            AugmentationSchema which is contains data about agumentation\r
 865      *            (target path, childs...)\r
 866      * @return list of <code>Type</code> objects which contains generated type\r
 867      *         for augmentation and for container, list and choice child nodes\r
 868      * @throws IllegalArgumentException\r
 869      *             <ul>\r
 870      *             <li>if <code>augmentPackageName</code> equals null</li>\r
 871      *             <li>if <code>augSchema</code> equals null</li>\r
 872      *             <li>if target path of <code>augSchema</code> equals null</li>\r
 873      *             </ul>\r
 874      */\r
 875     private def List<Type> augmentationToGenTypes( String augmentPackageName, AugmentationSchema augSchema) {\r
 876         checkArgument(augmentPackageName !== null,"Package Name cannot be NULL.");\r
 877         checkArgument(augSchema !== null,"Augmentation Schema cannot be NULL.");\r
 878         checkState(augSchema.targetPath !== null,"Augmentation Schema does not contain Target Path (Target Path is NULL).");\r
 879 \r
 880         val List<Type> genTypes = new ArrayList();\r
 881 \r
 882         // EVERY augmented interface will extends Augmentation<T> interface\r
 883         // and DataObject interface!!!\r
 884         val targetPath = augSchema.targetPath;\r
 885         val targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);\r
 886         val targetType = yangToJavaMapping.get(targetSchemaNode.path);\r
 887         if ((targetSchemaNode !== null) && (targetSchemaNode.QName !== null)\r
 888                 && (targetSchemaNode.QName.localName !== null)) {\r
 889             \r
 890             val targetPackageName = targetType.packageName;\r
 891             val targetSchemaNodeName = targetType.name;\r
 892             \r
 893             \r
 894             val augChildNodes = augSchema.childNodes;\r
 895 \r
 896             if (!(targetSchemaNode instanceof ChoiceNode)) {\r
 897                 val augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName,\r
 898                         targetType, augSchema);\r
 899                 val augType = augTypeBuilder.toInstance();\r
 900                 genTypes.add(augType);\r
 901             } else {\r
 902                 val refChoiceType = new ReferencedTypeImpl(targetPackageName,\r
 903                         parseToClassName(targetSchemaNodeName));\r
 904                 val choiceTarget = targetSchemaNode as ChoiceNode;\r
 905                 val choiceCaseNodes = choiceTarget.cases;\r
 906                 genTypes.addAll(generateTypesFromAugmentedChoiceCases(augmentPackageName, refChoiceType,\r
 907                         choiceCaseNodes));\r
 908             }\r
 909             genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName, augChildNodes));\r
 910         }\r
 911         return genTypes;\r
 912     }\r
 913 \r
 914     /**\r
 915      * Returns a generated type builder for an augmentation.\r
 916      *\r
 917      * The name of the type builder is equal to the name of augmented node with\r
 918      * serial number as suffix.\r
 919      *\r
 920      * @param augmentPackageName\r
 921      *            string with contains the package name to which the augment\r
 922      *            belongs\r
 923      * @param targetPackageName\r
 924      *            string with the package name to which the augmented node\r
 925      *            belongs\r
 926      * @param targetSchemaNodeName\r
 927      *            string with the name of the augmented node\r
 928      * @param augSchema\r
 929      *            augmentation schema which contains data about the child nodes\r
 930      *            and uses of augment\r
 931      * @return generated type builder for augment\r
 932      */\r
 933     private def GeneratedTypeBuilder addRawAugmentGenTypeDefinition( String augmentPackageName,\r
 934             Type targetTypeRef, AugmentationSchema augSchema) {\r
 935         var Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);\r
 936         if (augmentBuilders === null) {\r
 937             augmentBuilders = new HashMap();\r
 938             genTypeBuilders.put(augmentPackageName, augmentBuilders);\r
 939         }\r
 940         val augIdentifier = getAugmentIdentifier(augSchema.unknownSchemaNodes);\r
 941 \r
 942         val augTypeName = if (augIdentifier !== null ) { \r
 943             parseToClassName(augIdentifier)\r
 944         } else {\r
 945             augGenTypeName(augmentBuilders, targetTypeRef.name);\r
 946         }\r
 947         val Set<DataSchemaNode> augChildNodes = augSchema.childNodes;\r
 948 \r
 949         val augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);\r
 950 \r
 951         augTypeBuilder.addImplementsType(DATA_OBJECT);\r
 952         augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));\r
 953         addImplementedInterfaceFromUses(augSchema, augTypeBuilder);\r
 954 \r
 955         augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);\r
 956         augmentBuilders.put(augTypeName, augTypeBuilder);\r
 957         return augTypeBuilder;\r
 958     }\r
 959 \r
 960     /**\r
 961      *\r
 962      * @param unknownSchemaNodes\r
 963      * @return\r
 964      */\r
 965     private def String getAugmentIdentifier(List<UnknownSchemaNode> unknownSchemaNodes) {\r
 966         for (unknownSchemaNode : unknownSchemaNodes) {\r
 967             val nodeType = unknownSchemaNode.nodeType;\r
 968             if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.localName)\r
 969                     && YANG_EXT_NAMESPACE.equals(nodeType.namespace.toString())) {\r
 970                 return unknownSchemaNode.nodeParameter;\r
 971             }\r
 972         }\r
 973         return null;\r
 974     }\r
 975 \r
 976     /**\r
 977      * Convert a container, list and choice subnodes (and recursivelly their\r
 978      * subnodes) of augment to generated types\r
 979      *\r
 980      * @param augBasePackageName\r
 981      *            string with the augment package name\r
 982      * @param augChildNodes\r
 983      *            set of data schema nodes which represents child nodes of the\r
 984      *            augment\r
 985      *\r
 986      * @return list of <code>Type</code> which represents container, list and\r
 987      *         choice subnodes of augment\r
 988      */\r
 989     private def List<Type> augmentationBodyToGenTypes( String augBasePackageName,\r
 990             Set<DataSchemaNode> augChildNodes) {\r
 991         val List<Type> genTypes = new ArrayList();\r
 992         val List<DataNodeIterator> augSchemaIts = new ArrayList();\r
 993         for (childNode : augChildNodes) {\r
 994             if (childNode instanceof DataNodeContainer) {\r
 995                 augSchemaIts.add(new DataNodeIterator(childNode as DataNodeContainer));\r
 996 \r
 997                 if (childNode instanceof ContainerSchemaNode) {\r
 998                     genTypes.add(containerToGenType(augBasePackageName, childNode as ContainerSchemaNode));\r
 999                 } else if (childNode instanceof ListSchemaNode) {\r
1000                     genTypes.addAll(listToGenType(augBasePackageName, childNode as ListSchemaNode));\r
1001                 }\r
1002             } else if (childNode instanceof ChoiceNode) {\r
1003                 val choice = childNode as ChoiceNode;\r
1004                 for (caseNode : choice.cases) {\r
1005                     augSchemaIts.add(new DataNodeIterator(caseNode));\r
1006                 }\r
1007                 genTypes.addAll(choiceToGeneratedType(augBasePackageName, childNode as ChoiceNode));\r
1008             }\r
1009         }\r
1010 \r
1011         for (it : augSchemaIts) {\r
1012             val List<ContainerSchemaNode> augContainers = it.allContainers();\r
1013             val List<ListSchemaNode> augLists = it.allLists();\r
1014             val List<ChoiceNode> augChoices = it.allChoices();\r
1015 \r
1016             if (augContainers !== null) {\r
1017                 for (container : augContainers) {\r
1018                     genTypes.add(containerToGenType(augBasePackageName, container));\r
1019                 }\r
1020             }\r
1021             if (augLists !== null) {\r
1022                 for (list : augLists) {\r
1023                     genTypes.addAll(listToGenType(augBasePackageName, list));\r
1024                 }\r
1025             }\r
1026             if (augChoices !== null) {\r
1027                 for (choice : augChoices) {\r
1028                     genTypes.addAll(choiceToGeneratedType(augBasePackageName, choice));\r
1029                 }\r
1030             }\r
1031         }\r
1032         return genTypes;\r
1033     }\r
1034 \r
1035     /**\r
1036      * Returns first unique name for the augment generated type builder. The\r
1037      * generated type builder name for augment consists from name of augmented\r
1038      * node and serial number of its augmentation.\r
1039      *\r
1040      * @param builders\r
1041      *            map of builders which were created in the package to which the\r
1042      *            augmentation belongs\r
1043      * @param genTypeName\r
1044      *            string with name of augmented node\r
1045      * @return string with unique name for augmentation builder\r
1046      */\r
1047     private def String augGenTypeName( Map<String, GeneratedTypeBuilder> builders, String genTypeName) {\r
1048         var index = 1;\r
1049         while ((builders !== null) && builders.containsKey(genTypeName + index)) {\r
1050             index = index + 1;\r
1051         }\r
1052         return genTypeName + index;\r
1053     }\r
1054 \r
1055     /**\r
1056      * Converts <code>containerNode</code> to generated type. Firstly the\r
1057      * generated type builder is created. The subnodes of\r
1058      * <code>containerNode</code> are added as methods and the instance of\r
1059      * <code>GeneratedType</code> is returned.\r
1060      *\r
1061      * @param basePackageName\r
1062      *            string contains the module package name\r
1063      * @param containerNode\r
1064      *            container schema node with the data about childs nodes and\r
1065      *            schema paths\r
1066      * @return generated type for <code>containerNode</code>\r
1067      */\r
1068     private def GeneratedType containerToGenType( String basePackageName, ContainerSchemaNode containerNode) {\r
1069         if (containerNode === null) {\r
1070             return null;\r
1071         }\r
1072 \r
1073         val packageName = packageNameForGeneratedType(basePackageName, containerNode.path);\r
1074         val schemaNodes = containerNode.childNodes;\r
1075         val typeBuilder = addDefaultInterfaceDefinition(packageName, containerNode);\r
1076 \r
1077         resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
1078         return typeBuilder.toInstance();\r
1079     }\r
1080 \r
1081     /**\r
1082      * Adds the methods to <code>typeBuilder</code> which represent subnodes of\r
1083      * node for which <code>typeBuilder</code> was created.\r
1084      *\r
1085      * The subnodes aren't mapped to the methods if they are part of grouping or\r
1086      * augment (in this case are already part of them).\r
1087      *\r
1088      * @param basePackageName\r
1089      *            string contains the module package name\r
1090      * @param typeBuilder\r
1091      *            generated type builder which represents any node. The subnodes\r
1092      *            of this node are added to the <code>typeBuilder</code> as\r
1093      *            methods. The subnode can be of type leaf, leaf-list, list,\r
1094      *            container, choice.\r
1095      * @param schemaNodes\r
1096      *            set of data schema nodes which are the children of the node\r
1097      *            for which <code>typeBuilder</code> was created\r
1098      * @return generated type builder which is the same builder as input\r
1099      *         parameter. The getter methods (representing child nodes) could be\r
1100      *         added to it.\r
1101      */\r
1102     private def GeneratedTypeBuilder resolveDataSchemaNodes( String basePackageName,\r
1103             GeneratedTypeBuilder typeBuilder, Set<DataSchemaNode> schemaNodes) {\r
1104         if ((schemaNodes !== null) && (typeBuilder !== null)) {\r
1105             for (schemaNode : schemaNodes) {\r
1106                 if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {\r
1107                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
1108                 }\r
1109                 \r
1110             }\r
1111         }\r
1112         return typeBuilder;\r
1113     }\r
1114 \r
1115     /**\r
1116      * Adds the methods to <code>typeBuilder</code> what represents subnodes of\r
1117      * node for which <code>typeBuilder</code> was created.\r
1118      *\r
1119      * @param basePackageName\r
1120      *            string contains the module package name\r
1121      * @param typeBuilder\r
1122      *            generated type builder which represents any node. The subnodes\r
1123      *            of this node are added to the <code>typeBuilder</code> as\r
1124      *            methods. The subnode can be of type leaf, leaf-list, list,\r
1125      *            container, choice.\r
1126      * @param schemaNodes\r
1127      *            set of data schema nodes which are the children of the node\r
1128      *            for which <code>typeBuilder</code> was created\r
1129      * @return generated type builder which is the same object as the input\r
1130      *         parameter <code>typeBuilder</code>. The getter method could be\r
1131      *         added to it.\r
1132      */\r
1133     private def GeneratedTypeBuilder augSchemaNodeToMethods( String basePackageName,\r
1134              GeneratedTypeBuilder typeBuilder,  Set<DataSchemaNode> schemaNodes) {\r
1135         if ((schemaNodes !== null) && (typeBuilder !== null)) {\r
1136             for (schemaNode : schemaNodes) {\r
1137                 if (schemaNode.isAugmenting()) {\r
1138                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
1139                 }\r
1140             }\r
1141         }\r
1142         return typeBuilder;\r
1143     }\r
1144 \r
1145     /**\r
1146      * Adds to <code>typeBuilder</code> a method which is derived from\r
1147      * <code>schemaNode</code>.\r
1148      *\r
1149      * @param basePackageName\r
1150      *            string with the module package name\r
1151      * @param schemaNode\r
1152      *            data schema node which is added to <code>typeBuilder</code> as\r
1153      *            a method\r
1154      * @param typeBuilder\r
1155      *            generated type builder to which is <code>schemaNode</code>\r
1156      *            added as a method.\r
1157      */\r
1158     private def void addSchemaNodeToBuilderAsMethod( String basePackageName,  DataSchemaNode node,\r
1159              GeneratedTypeBuilder typeBuilder) {\r
1160         if (node !== null && typeBuilder !== null) {\r
1161             switch(node) {\r
1162                 case node instanceof LeafSchemaNode: resolveLeafSchemaNodeAsMethod(typeBuilder, node as LeafSchemaNode)\r
1163                 case node instanceof LeafListSchemaNode: resolveLeafListSchemaNode(typeBuilder, node as LeafListSchemaNode)\r
1164                 case node instanceof ContainerSchemaNode: resolveContainerSchemaNode(basePackageName, typeBuilder, node as ContainerSchemaNode)\r
1165                 case node instanceof ListSchemaNode: resolveListSchemaNode(basePackageName, typeBuilder, node as ListSchemaNode)\r
1166                 case node instanceof ChoiceNode: resolveChoiceSchemaNode(basePackageName, typeBuilder, node as ChoiceNode)\r
1167             }\r
1168         }\r
1169     }\r
1170 \r
1171     /**\r
1172      * Creates a getter method for a choice node.\r
1173      *\r
1174      * Firstly generated type builder for choice is created or found in\r
1175      * {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name\r
1176      * in the builder is created as concatenation of module package name and\r
1177      * names of all parent nodes. In the end the getter method for choice is\r
1178      * added to <code>typeBuilder</code> and return type is set to choice\r
1179      * builder.\r
1180      *\r
1181      * @param basePackageName\r
1182      *            string with the module package name\r
1183      * @param typeBuilder\r
1184      *            generated type builder to which is <code>choiceNode</code>\r
1185      *            added as getter method\r
1186      * @param choiceNode\r
1187      *            choice node which is mapped as a getter method\r
1188      * @throws IllegalArgumentException\r
1189      *             <ul>\r
1190      *             <li>if <code>basePackageName</code> equals null</li>\r
1191      *             <li>if <code>typeBuilder</code> equals null</li>\r
1192      *             <li>if <code>choiceNode</code> equals null</li>\r
1193      *             </ul>\r
1194      *\r
1195      */\r
1196     private def void resolveChoiceSchemaNode( String basePackageName,  GeneratedTypeBuilder typeBuilder,\r
1197              ChoiceNode choiceNode) {\r
1198         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1199         checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
1200         checkArgument(choiceNode !== null,"Choice Schema Node cannot be NULL.");\r
1201 \r
1202         val choiceName = choiceNode.QName.localName;\r
1203         if (choiceName !== null && !choiceNode.isAddedByUses()) {\r
1204             val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);\r
1205             val choiceType = addDefaultInterfaceDefinition(packageName, choiceNode);\r
1206             constructGetter(typeBuilder, choiceName, choiceNode.description, choiceType);\r
1207         }\r
1208     }\r
1209 \r
1210     /**\r
1211      * Converts <code>choiceNode</code> to the list of generated types for\r
1212      * choice and its cases.\r
1213      *\r
1214      * The package names for choice and for its cases are created as\r
1215      * concatenation of the module package (<code>basePackageName</code>) and\r
1216      * names of all parents node.\r
1217      *\r
1218      * @param basePackageName\r
1219      *            string with the module package name\r
1220      * @param choiceNode\r
1221      *            choice node which is mapped to generated type. Also child\r
1222      *            nodes - cases are mapped to generated types.\r
1223      * @return list of generated types which contains generated type for choice\r
1224      *         and generated types for all cases which aren't added do choice\r
1225      *         through <i>uses</i>.\r
1226      * @throws IllegalArgumentException\r
1227      *             <ul>\r
1228      *             <li>if <code>basePackageName</code> equals null</li>\r
1229      *             <li>if <code>choiceNode</code> equals null</li>\r
1230      *             </ul>\r
1231      *\r
1232      */\r
1233     private def List<GeneratedType> choiceToGeneratedType( String basePackageName,  ChoiceNode choiceNode) {\r
1234         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1235         checkArgument(choiceNode !== null,"Choice Schema Node cannot be NULL.");\r
1236 \r
1237         val List<GeneratedType> generatedTypes = new ArrayList();\r
1238         val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);\r
1239         val choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);\r
1240         //choiceTypeBuilder.addImplementsType(DATA_OBJECT);\r
1241         val choiceType = choiceTypeBuilder.toInstance();\r
1242 \r
1243         generatedTypes.add(choiceType);\r
1244         val Set<ChoiceCaseNode> caseNodes = choiceNode.cases;\r
1245         if ((caseNodes !== null) && !caseNodes.isEmpty()) {\r
1246             generatedTypes.addAll(generateTypesFromChoiceCases(basePackageName, choiceType, caseNodes));\r
1247         }\r
1248         return generatedTypes;\r
1249     }\r
1250 \r
1251     /**\r
1252      * Converts <code>caseNodes</code> set to list of corresponding generated\r
1253      * types.\r
1254      *\r
1255      * For every <i>case</i> which isn't added through augment or <i>uses</i> is\r
1256      * created generated type builder. The package names for the builder is\r
1257      * created as concatenation of the module package (\r
1258      * <code>basePackageName</code>) and names of all parents nodes of the\r
1259      * concrete <i>case</i>. There is also relation "<i>implements type</i>"\r
1260      * between every case builder and <i>choice</i> type\r
1261      *\r
1262      * @param basePackageName\r
1263      *            string with the module package name\r
1264      * @param refChoiceType\r
1265      *            type which represents superior <i>case</i>\r
1266      * @param caseNodes\r
1267      *            set of choice case nodes which are mapped to generated types\r
1268      * @return list of generated types for <code>caseNodes</code>.\r
1269      * @throws IllegalArgumentException\r
1270      *             <ul>\r
1271      *             <li>if <code>basePackageName</code> equals null</li>\r
1272      *             <li>if <code>refChoiceType</code> equals null</li>\r
1273      *             <li>if <code>caseNodes</code> equals null</li>\r
1274      *             </ul>\r
1275      *             *\r
1276      */\r
1277     private def List<GeneratedType> generateTypesFromChoiceCases( String basePackageName,  Type refChoiceType,\r
1278              Set<ChoiceCaseNode> caseNodes) {\r
1279         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1280         checkArgument(refChoiceType !== null,"Referenced Choice Type cannot be NULL.");\r
1281         checkArgument(caseNodes !== null,"Set of Choice Case Nodes cannot be NULL.");\r
1282 \r
1283         val List<GeneratedType> generatedTypes = new ArrayList();\r
1284         for (caseNode : caseNodes) {\r
1285             if (caseNode !== null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {\r
1286                 val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
1287                 val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
1288                 caseTypeBuilder.addImplementsType(refChoiceType);\r
1289 \r
1290                 val Set<DataSchemaNode> childNodes = caseNode.childNodes;\r
1291                 if (childNodes !== null) {\r
1292                     resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);\r
1293                 }\r
1294                 generatedTypes.add(caseTypeBuilder.toInstance());\r
1295             }\r
1296         }\r
1297 \r
1298         return generatedTypes;\r
1299     }\r
1300 \r
1301     /**\r
1302      * Generates list of generated types for all the cases of a choice which are\r
1303      * added to the choice through the augment.\r
1304      *\r
1305      *\r
1306      * @param basePackageName\r
1307      *            string contains name of package to which augment belongs. If\r
1308      *            an augmented choice is from an other package (pcg1) than an\r
1309      *            augmenting choice (pcg2) then case's of the augmenting choice\r
1310      *            will belong to pcg2.\r
1311      * @param refChoiceType\r
1312      *            Type which represents the choice to which case belongs. Every\r
1313      *            case has to contain its choice in extend part.\r
1314      * @param caseNodes\r
1315      *            set of choice case nodes for which is checked if are/aren't\r
1316      *            added to choice through augmentation\r
1317      * @return list of generated types which represents augmented cases of\r
1318      *         choice <code>refChoiceType</code>\r
1319      * @throws IllegalArgumentException\r
1320      *             <ul>\r
1321      *             <li>if <code>basePackageName</code> equals null</li>\r
1322      *             <li>if <code>refChoiceType</code> equals null</li>\r
1323      *             <li>if <code>caseNodes</code> equals null</li>\r
1324      *             </ul>\r
1325      */\r
1326     private def List<GeneratedType> generateTypesFromAugmentedChoiceCases( String basePackageName,\r
1327              Type refChoiceType,  Set<ChoiceCaseNode> caseNodes) {\r
1328         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1329         checkArgument(refChoiceType !== null,"Referenced Choice Type cannot be NULL.");\r
1330         checkArgument(caseNodes !== null,"Set of Choice Case Nodes cannot be NULL.");\r
1331 \r
1332         val List<GeneratedType> generatedTypes = new ArrayList();\r
1333         for (caseNode : caseNodes) {\r
1334             if (caseNode !== null && caseNode.isAugmenting()) {\r
1335                 val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
1336                 val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
1337                 caseTypeBuilder.addImplementsType(refChoiceType);\r
1338 \r
1339                 val Set<DataSchemaNode> childNodes = caseNode.childNodes;\r
1340                 if (childNodes !== null) {\r
1341                     resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);\r
1342                 }\r
1343                 generatedTypes.add(caseTypeBuilder.toInstance());\r
1344             }\r
1345         }\r
1346 \r
1347         return generatedTypes;\r
1348     }\r
1349 \r
1350     /**\r
1351      * Converts <code>leaf</code> to the getter method which is added to\r
1352      * <code>typeBuilder</code>.\r
1353      *\r
1354      * @param typeBuilder\r
1355      *            generated type builder to which is added getter method as\r
1356      *            <code>leaf</code> mapping\r
1357      * @param leaf\r
1358      *            leaf schema node which is mapped as getter method which is\r
1359      *            added to <code>typeBuilder</code>\r
1360      * @return boolean value\r
1361      *         <ul>\r
1362      *         <li>false - if <code>leaf</code> or <code>typeBuilder</code> are\r
1363      *         null</li>\r
1364      *         <li>true - in other cases</li>\r
1365      *         </ul>\r
1366      */\r
1367     private def boolean resolveLeafSchemaNodeAsMethod( GeneratedTypeBuilder typeBuilder,  LeafSchemaNode leaf) {\r
1368         if ((leaf !== null) && (typeBuilder !== null)) {\r
1369             val leafName = leaf.QName.localName;\r
1370             var String leafDesc = leaf.description;\r
1371             if (leafDesc === null) {\r
1372                 leafDesc = "";\r
1373             }\r
1374 \r
1375             val parentModule = findParentModule(schemaContext, leaf);\r
1376             if (leafName !== null && !leaf.isAddedByUses()) {\r
1377                 val TypeDefinition<?> typeDef = leaf.type;\r
1378 \r
1379                 var Type returnType = null;\r
1380                 if (typeDef instanceof EnumTypeDefinition) {\r
1381                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
1382                     val enumTypeDef = enumTypeDefFromExtendedType(typeDef);\r
1383                     val enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leafName,\r
1384                             typeBuilder);\r
1385 \r
1386                     if (enumBuilder !== null) {\r
1387                         returnType = new ReferencedTypeImpl(enumBuilder.packageName, enumBuilder.name);\r
1388                     }\r
1389                     (typeProvider as TypeProviderImpl).putReferencedType(leaf.path, returnType);\r
1390                 } else if (typeDef instanceof UnionType) {\r
1391                     val genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
1392                     if (genTOBuilder !== null) {\r
1393                         returnType = new ReferencedTypeImpl(genTOBuilder.packageName, genTOBuilder.name);\r
1394                     }\r
1395                 } else if (typeDef instanceof BitsTypeDefinition) {\r
1396                     val genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
1397                     if (genTOBuilder !== null) {\r
1398                         returnType = new ReferencedTypeImpl(genTOBuilder.packageName, genTOBuilder.name);\r
1399                     }\r
1400                 } else {\r
1401                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
1402                 }\r
1403                 if (returnType !== null) {\r
1404                     constructGetter(typeBuilder, leafName, leafDesc, returnType);\r
1405                     return true;\r
1406                 }\r
1407             }\r
1408         }\r
1409         return false;\r
1410     }\r
1411 \r
1412     /**\r
1413      * Converts <code>leaf</code> schema node to property of generated TO\r
1414      * builder.\r
1415      *\r
1416      * @param toBuilder\r
1417      *            generated TO builder to which is <code>leaf</code> added as\r
1418      *            property\r
1419      * @param leaf\r
1420      *            leaf schema node which is added to <code>toBuilder</code> as\r
1421      *            property\r
1422      * @param isReadOnly\r
1423      *            boolean value which says if leaf property is|isn't read only\r
1424      * @return boolean value\r
1425      *         <ul>\r
1426      *         <li>false - if <code>leaf</code>, <code>toBuilder</code> or leaf\r
1427      *         name equals null or if leaf is added by <i>uses</i>.</li>\r
1428      *         <li>true - other cases</li>\r
1429      *         </ul>\r
1430      */\r
1431     private def boolean resolveLeafSchemaNodeAsProperty( GeneratedTOBuilder toBuilder, LeafSchemaNode leaf,\r
1432             boolean isReadOnly) {\r
1433         if ((leaf !== null) && (toBuilder !== null)) {\r
1434             val leafName = leaf.QName.localName;\r
1435             var String leafDesc = leaf.description;\r
1436             if (leafDesc === null) {\r
1437                 leafDesc = "";\r
1438             }\r
1439 \r
1440             if (leafName !== null && !leaf.isAddedByUses()) {\r
1441                 val TypeDefinition<?> typeDef = leaf.type;\r
1442 \r
1443                 // TODO: properly resolve enum types\r
1444                 val returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
1445 \r
1446                 if (returnType !== null) {\r
1447                     val propBuilder = toBuilder.addProperty(parseToClassName(leafName));\r
1448 \r
1449                     propBuilder.setReadOnly(isReadOnly);\r
1450                     propBuilder.setReturnType(returnType);\r
1451                     propBuilder.setComment(leafDesc);\r
1452 \r
1453                     toBuilder.addEqualsIdentity(propBuilder);\r
1454                     toBuilder.addHashIdentity(propBuilder);\r
1455                     toBuilder.addToStringProperty(propBuilder);\r
1456 \r
1457                     return true;\r
1458                 }\r
1459             }\r
1460         }\r
1461         return false;\r
1462     }\r
1463 \r
1464     /**\r
1465      * Converts <code>node</code> leaf list schema node to getter method of\r
1466      * <code>typeBuilder</code>.\r
1467      *\r
1468      * @param typeBuilder\r
1469      *            generated type builder to which is <code>node</code> added as\r
1470      *            getter method\r
1471      * @param node\r
1472      *            leaf list schema node which is added to\r
1473      *            <code>typeBuilder</code> as getter method\r
1474      * @return boolean value\r
1475      *         <ul>\r
1476      *         <li>true - if <code>node</code>, <code>typeBuilder</code>,\r
1477      *         nodeName equal null or <code>node</code> is added by <i>uses</i></li>\r
1478      *         <li>false - other cases</li>\r
1479      *         </ul>\r
1480      */\r
1481     private def boolean resolveLeafListSchemaNode( GeneratedTypeBuilder typeBuilder, LeafListSchemaNode node) {\r
1482         if ((node !== null) && (typeBuilder !== null)) {\r
1483             val nodeName = node.QName.localName;\r
1484             var String nodeDesc = node.description;\r
1485             if (nodeDesc === null) {\r
1486                 nodeDesc = "";\r
1487             }\r
1488 \r
1489             if (nodeName !== null && !node.isAddedByUses()) {\r
1490                 val TypeDefinition<?> type = node.type;\r
1491                 val listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type, node));\r
1492 \r
1493                 constructGetter(typeBuilder, nodeName, nodeDesc, listType);\r
1494                 return true;\r
1495             }\r
1496         }\r
1497         return false;\r
1498     }\r
1499 \r
1500     /**\r
1501      * Creates a getter method for a container node.\r
1502      *\r
1503      * Firstly generated type builder for container is created or found in\r
1504      * {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name\r
1505      * in the builder is created as concatenation of module package name and\r
1506      * names of all parent nodes. In the end the getter method for container is\r
1507      * added to <code>typeBuilder</code> and return type is set to container\r
1508      * type builder.\r
1509      *\r
1510      * @param basePackageName\r
1511      *            string with the module package name\r
1512      * @param typeBuilder\r
1513      *            generated type builder to which is <code>containerNode</code>\r
1514      *            added as getter method\r
1515      * @param containerNode\r
1516      *            container schema node which is mapped as getter method to\r
1517      *            <code>typeBuilder</code>\r
1518      * @return boolean value\r
1519      *         <ul>\r
1520      *         <li>false - if <code>containerNode</code>,\r
1521      *         <code>typeBuilder</code>, container node name equal null or\r
1522      *         <code>containerNode</code> is added by uses</li>\r
1523      *         <li>true - other cases</li>\r
1524      *         </ul>\r
1525      */\r
1526     private def boolean resolveContainerSchemaNode( String basePackageName, GeneratedTypeBuilder typeBuilder,\r
1527             ContainerSchemaNode containerNode) {\r
1528         if ((containerNode !== null) && (typeBuilder !== null)) {\r
1529             val nodeName = containerNode.QName.localName;\r
1530 \r
1531             if (nodeName !== null && !containerNode.isAddedByUses()) {\r
1532                 val packageName = packageNameForGeneratedType(basePackageName, containerNode.path);\r
1533 \r
1534                 val rawGenType = addDefaultInterfaceDefinition(packageName, containerNode);\r
1535                 constructGetter(typeBuilder, nodeName, containerNode.description, rawGenType);\r
1536 \r
1537                 return true;\r
1538             }\r
1539         }\r
1540         return false;\r
1541     }\r
1542 \r
1543     /**\r
1544      * Creates a getter method for a list node.\r
1545      *\r
1546      * Firstly generated type builder for list is created or found in\r
1547      * {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name\r
1548      * in the builder is created as concatenation of module package name and\r
1549      * names of all parent nodes. In the end the getter method for list is added\r
1550      * to <code>typeBuilder</code> and return type is set to list type builder.\r
1551      *\r
1552      * @param basePackageName\r
1553      *            string with the module package name\r
1554      * @param typeBuilder\r
1555      *            generated type builder to which is <code></code> added as\r
1556      *            getter method\r
1557      * @param listNode\r
1558      *            list schema node which is mapped as getter method to\r
1559      *            <code>typeBuilder</code>\r
1560      * @return boolean value\r
1561      *         <ul>\r
1562      *         <li>false - if <code>listNode</code>, <code>typeBuilder</code>,\r
1563      *         list node name equal null or <code>listNode</code> is added by\r
1564      *         uses</li>\r
1565      *         <li>true - other cases</li>\r
1566      *         </ul>\r
1567      */\r
1568     private def boolean resolveListSchemaNode( String basePackageName, GeneratedTypeBuilder typeBuilder,\r
1569             ListSchemaNode listNode) {\r
1570         if ((listNode !== null) && (typeBuilder !== null)) {\r
1571             val listName = listNode.QName.localName;\r
1572 \r
1573             if (listName !== null && !listNode.isAddedByUses()) {\r
1574                 val packageName = packageNameForGeneratedType(basePackageName, listNode.path);\r
1575                 val rawGenType = addDefaultInterfaceDefinition(packageName, listNode);\r
1576                 constructGetter(typeBuilder, listName, listNode.description, Types.listTypeFor(rawGenType));\r
1577                 return true;\r
1578             }\r
1579         }\r
1580         return false;\r
1581     }\r
1582 \r
1583     /**\r
1584      * Instantiates generated type builder with <code>packageName</code> and\r
1585      * <code>schemaNode</code>.\r
1586      *\r
1587      * The new builder always implements\r
1588      * {@link org.opendaylight.yangtools.yang.binding.DataObject DataObject}.<br />\r
1589      * If <code>schemaNode</code> is instance of GroupingDefinition it also\r
1590      * implements {@link org.opendaylight.yangtools.yang.binding.Augmentable\r
1591      * Augmentable}.<br />\r
1592      * If <code>schemaNode</code> is instance of\r
1593      * {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer\r
1594      * DataNodeContainer} it can also implement nodes which are specified in\r
1595      * <i>uses</i>.\r
1596      *\r
1597      * @param packageName\r
1598      *            string with the name of the package to which\r
1599      *            <code>schemaNode</code> belongs.\r
1600      * @param schemaNode\r
1601      *            schema node for which is created generated type builder\r
1602      * @return generated type builder <code>schemaNode</code>\r
1603      */\r
1604     private def GeneratedTypeBuilder addDefaultInterfaceDefinition( String packageName, SchemaNode schemaNode) {\r
1605         val builder = addRawInterfaceDefinition(packageName, schemaNode, "");\r
1606         builder.addImplementsType(DATA_OBJECT);\r
1607         if (!(schemaNode instanceof GroupingDefinition)) {\r
1608             builder.addImplementsType(augmentable(builder));\r
1609         }\r
1610 \r
1611         if (schemaNode instanceof DataNodeContainer) {\r
1612             addImplementedInterfaceFromUses( schemaNode as DataNodeContainer, builder);\r
1613         }\r
1614 \r
1615         return builder;\r
1616     }\r
1617 \r
1618     /**\r
1619      * Wraps the calling of the same overloaded method.\r
1620      *\r
1621      * @param packageName\r
1622      *            string with the package name to which returning generated type\r
1623      *            builder belongs\r
1624      * @param schemaNode\r
1625      *            schema node which provide data about the schema node name\r
1626      * @return generated type builder for <code>schemaNode</code>\r
1627      */\r
1628     private def GeneratedTypeBuilder addRawInterfaceDefinition( String packageName,  SchemaNode schemaNode) {\r
1629         return addRawInterfaceDefinition(packageName, schemaNode, "");\r
1630     }\r
1631 \r
1632     /**\r
1633      * Returns reference to generated type builder for specified\r
1634      * <code>schemaNode</code> with <code>packageName</code>.\r
1635      *\r
1636      * Firstly the generated type builder is searched in\r
1637      * {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't\r
1638      * found it is created and added to <code>genTypeBuilders</code>.\r
1639      *\r
1640      * @param packageName\r
1641      *            string with the package name to which returning generated type\r
1642      *            builder belongs\r
1643      * @param schemaNode\r
1644      *            schema node which provide data about the schema node name\r
1645      * @return generated type builder for <code>schemaNode</code>\r
1646      * @throws IllegalArgumentException\r
1647      *             <ul>\r
1648      *             <li>if <code>schemaNode</code> equals null</li>\r
1649      *             <li>if <code>packageName</code> equals null</li>\r
1650      *             <li>if Q name of schema node is null</li>\r
1651      *             <li>if schema node name is nul</li>\r
1652      *             </ul>\r
1653      *\r
1654      */\r
1655     private def GeneratedTypeBuilder addRawInterfaceDefinition( String packageName,  SchemaNode schemaNode,\r
1656              String prefix) {\r
1657         checkArgument(schemaNode !== null,"Data Schema Node cannot be NULL.");\r
1658         checkArgument(packageName !== null,"Package Name for Generated Type cannot be NULL.");\r
1659         checkArgument(schemaNode.QName !== null,"QName for Data Schema Node cannot be NULL.");\r
1660         val schemaNodeName = schemaNode.QName.localName;\r
1661         checkArgument(schemaNodeName !== null,"Local Name of QName for Data Schema Node cannot be NULL.");\r
1662 \r
1663         var String genTypeName;\r
1664         if (prefix === null) {\r
1665             genTypeName = parseToClassName(schemaNodeName);\r
1666         } else {\r
1667             genTypeName = prefix + parseToClassName(schemaNodeName);\r
1668         }\r
1669         //FIXME: Validation of name conflict\r
1670         val newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);\r
1671         yangToJavaMapping.put(schemaNode.path,newType);\r
1672         if (!genTypeBuilders.containsKey(packageName)) {\r
1673             val Map<String, GeneratedTypeBuilder> builders = new HashMap();\r
1674             builders.put(genTypeName, newType);\r
1675             genTypeBuilders.put(packageName, builders);\r
1676         } else {\r
1677             val Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);\r
1678             if (!builders.containsKey(genTypeName)) {\r
1679                 builders.put(genTypeName, newType);\r
1680             }\r
1681         }\r
1682         return newType;\r
1683     }\r
1684 \r
1685     /**\r
1686      * Creates the name of the getter method from <code>methodName</code>.\r
1687      *\r
1688      * @param methodName\r
1689      *            string with the name of the getter method\r
1690      * @return string with the name of the getter method for\r
1691      *         <code>methodName</code> in JAVA method format\r
1692      */\r
1693     private def String getterMethodName( String methodName,Type returnType) {\r
1694         val method = new StringBuilder();\r
1695         if(BOOLEAN.equals(returnType)) {\r
1696             method.append("is");\r
1697         } else {\r
1698             method.append("get");\r
1699         }\r
1700         method.append(parseToClassName(methodName));\r
1701         return method.toString();\r
1702     }\r
1703 \r
1704     /**\r
1705      * Created a method signature builder as part of\r
1706      * <code>interfaceBuilder</code>.\r
1707      *\r
1708      * The method signature builder is created for the getter method of\r
1709      * <code>schemaNodeName</code>. Also <code>comment</code> and\r
1710      * <code>returnType</code> information are added to the builder.\r
1711      *\r
1712      * @param interfaceBuilder\r
1713      *            generated type builder for which the getter method should be\r
1714      *            created\r
1715      * @param schemaNodeName\r
1716      *            string with schema node name. The name will be the part of the\r
1717      *            getter method name.\r
1718      * @param comment\r
1719      *            string with comment for the getter method\r
1720      * @param returnType\r
1721      *            type which represents the return type of the getter method\r
1722      * @return method signature builder which represents the getter method of\r
1723      *         <code>interfaceBuilder</code>\r
1724      */\r
1725     private def MethodSignatureBuilder constructGetter( GeneratedTypeBuilder interfaceBuilder,\r
1726              String schemaNodeName,  String comment,  Type returnType) {\r
1727 \r
1728         val getMethod = interfaceBuilder.addMethod(getterMethodName(schemaNodeName,returnType));\r
1729 \r
1730         getMethod.setComment(comment);\r
1731         getMethod.setReturnType(returnType);\r
1732 \r
1733         return getMethod;\r
1734     }\r
1735 \r
1736     private def listToGenType( String basePackageName,  ListSchemaNode list) {\r
1737         checkArgument(basePackageName !== null,"Package Name for Generated Type cannot be NULL.");\r
1738         checkArgument(list !== null,"List Schema Node cannot be NULL.");\r
1739 \r
1740         val packageName = packageNameForGeneratedType(basePackageName, list.path);\r
1741         // val typeBuilder =\r
1742         // resolveListTypeBuilder(packageName, list);\r
1743         val typeBuilder = addDefaultInterfaceDefinition(packageName, list);\r
1744 \r
1745         val List<String> listKeys = listKeys(list);\r
1746         val genTOBuilder = resolveListKeyTOBuilder(packageName, list);\r
1747 \r
1748         if (genTOBuilder !== null) {\r
1749             val identifierMarker = IDENTIFIER.parameterizedTypeFor(typeBuilder);\r
1750             val identifiableMarker = IDENTIFIABLE.parameterizedTypeFor(genTOBuilder);\r
1751             genTOBuilder.addImplementsType(identifierMarker);\r
1752             typeBuilder.addImplementsType(identifiableMarker);\r
1753         }\r
1754         val schemaNodes = list.childNodes;\r
1755 \r
1756         for (schemaNode : schemaNodes) {\r
1757             if (!schemaNode.isAugmenting()) {\r
1758                 addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);\r
1759             }\r
1760         }\r
1761         return typeBuildersToGenTypes(typeBuilder, genTOBuilder);\r
1762     }\r
1763 \r
1764     /**\r
1765      * Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method\r
1766      * or to <code>genTOBuilder</code> as property.\r
1767      *\r
1768      * @param basePackageName\r
1769      *            string contains the module package name\r
1770      * @param schemaNode\r
1771      *            data schema node which should be added as getter method to\r
1772      *            <code>typeBuilder</code> or as a property to\r
1773      *            <code>genTOBuilder</code> if is part of the list key\r
1774      * @param typeBuilder\r
1775      *            generated type builder for the list schema node\r
1776      * @param genTOBuilder\r
1777      *            generated TO builder for the list keys\r
1778      * @param listKeys\r
1779      *            list of string which contains names of the list keys\r
1780      * @throws IllegalArgumentException\r
1781      *             <ul>\r
1782      *             <li>if <code>schemaNode</code> equals null</li>\r
1783      *             <li>if <code>typeBuilder</code> equals null</li>\r
1784      *             </ul>\r
1785      */\r
1786     private def void addSchemaNodeToListBuilders( String basePackageName,  DataSchemaNode schemaNode,\r
1787              GeneratedTypeBuilder typeBuilder,  GeneratedTOBuilder genTOBuilder,  List<String> listKeys) {\r
1788         checkArgument(schemaNode !== null,"Data Schema Node cannot be NULL.");\r
1789 \r
1790         checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
1791 \r
1792         if (schemaNode instanceof LeafSchemaNode) {\r
1793             val leaf = schemaNode as LeafSchemaNode;\r
1794             val leafName = leaf.QName.localName;\r
1795             if (!listKeys.contains(leafName)) {\r
1796                 resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);\r
1797             } else {\r
1798                 resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);\r
1799             }\r
1800         } else if (schemaNode instanceof LeafListSchemaNode) {\r
1801             resolveLeafListSchemaNode(typeBuilder,  schemaNode as LeafListSchemaNode);\r
1802         } else if (schemaNode instanceof ContainerSchemaNode) {\r
1803             resolveContainerSchemaNode(basePackageName, typeBuilder, schemaNode as ContainerSchemaNode);\r
1804         } else if (schemaNode instanceof ListSchemaNode) {\r
1805             resolveListSchemaNode(basePackageName, typeBuilder, schemaNode as ListSchemaNode);\r
1806         }\r
1807     }\r
1808 \r
1809     private def typeBuildersToGenTypes( GeneratedTypeBuilder typeBuilder, GeneratedTOBuilder genTOBuilder) {\r
1810         val List<Type> genTypes = new ArrayList();\r
1811         checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
1812 \r
1813         if (genTOBuilder !== null) {\r
1814             val genTO = genTOBuilder.toInstance();\r
1815             constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO);\r
1816             genTypes.add(genTO);\r
1817         }\r
1818         genTypes.add(typeBuilder.toInstance());\r
1819         return genTypes;\r
1820     }\r
1821 \r
1822     /**\r
1823      * Selects the names of the list keys from <code>list</code> and returns\r
1824      * them as the list of the strings\r
1825      *\r
1826      * @param list\r
1827      *            of string with names of the list keys\r
1828      * @return list of string which represents names of the list keys. If the\r
1829      *         <code>list</code> contains no keys then the empty list is\r
1830      *         returned.\r
1831      */\r
1832     private def listKeys( ListSchemaNode list) {\r
1833         val List<String> listKeys = new ArrayList();\r
1834 \r
1835         if (list.keyDefinition !== null) {\r
1836             val keyDefinitions = list.keyDefinition;\r
1837             for (keyDefinition : keyDefinitions) {\r
1838                 listKeys.add(keyDefinition.localName);\r
1839             }\r
1840         }\r
1841         return listKeys;\r
1842     }\r
1843 \r
1844     /**\r
1845      * Generates for the <code>list</code> which contains any list keys special\r
1846      * generated TO builder.\r
1847      *\r
1848      * @param packageName\r
1849      *            string with package name to which the list belongs\r
1850      * @param list\r
1851      *            list schema node which is source of data about the list name\r
1852      * @return generated TO builder which represents the keys of the\r
1853      *         <code>list</code> or null if <code>list</code> is null or list of\r
1854      *         key definitions is null or empty.\r
1855      */\r
1856     private def GeneratedTOBuilder resolveListKeyTOBuilder( String packageName,  ListSchemaNode list) {\r
1857         var GeneratedTOBuilder genTOBuilder = null;\r
1858         if ((list.keyDefinition !== null) && (!list.keyDefinition.isEmpty())) {\r
1859             if (list !== null) {\r
1860                 val listName = list.QName.localName + "Key";\r
1861                 genTOBuilder = schemaNodeToTransferObjectBuilder(packageName, listName);\r
1862             }\r
1863         }\r
1864         return genTOBuilder;\r
1865 \r
1866     }\r
1867 \r
1868     /**\r
1869      * Builds generated TO builders for <code>typeDef</code> of type\r
1870      * {@link org.opendaylight.yangtools.yang.model.util.UnionType UnionType} or\r
1871      * {@link org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition\r
1872      * BitsTypeDefinition} which are also added to <code>typeBuilder</code> as\r
1873      * enclosing transfer object.\r
1874      *\r
1875      * If more then one generated TO builder is created for enclosing then all\r
1876      * of the generated TO builders are added to <code>typeBuilder</code> as\r
1877      * enclosing transfer objects.\r
1878      *\r
1879      * @param typeDef\r
1880      *            type definition which can be of type <code>UnionType</code> or\r
1881      *            <code>BitsTypeDefinition</code>\r
1882      * @param typeBuilder\r
1883      *            generated type builder to which is added generated TO created\r
1884      *            from <code>typeDef</code>\r
1885      * @param leafName\r
1886      *            string with name for generated TO builder\r
1887      * @return generated TO builder for <code>typeDef</code>\r
1888      */\r
1889     private def GeneratedTOBuilder addTOToTypeBuilder(TypeDefinition<?> typeDef, GeneratedTypeBuilder typeBuilder,\r
1890             String leafName, LeafSchemaNode leaf, Module parentModule) {\r
1891         val classNameFromLeaf = parseToClassName(leafName);\r
1892         val List<GeneratedTOBuilder> genTOBuilders = new ArrayList();\r
1893         val packageName = typeBuilder.fullyQualifiedName;\r
1894         if (typeDef instanceof UnionTypeDefinition) {\r
1895             genTOBuilders.addAll((typeProvider as TypeProviderImpl).provideGeneratedTOBuildersForUnionTypeDef(\r
1896                     packageName, typeDef, classNameFromLeaf, leaf));\r
1897         } else if (typeDef instanceof BitsTypeDefinition) {\r
1898             genTOBuilders.add(((typeProvider as TypeProviderImpl) ).provideGeneratedTOBuilderForBitsTypeDefinition(\r
1899                     packageName, typeDef, classNameFromLeaf));\r
1900         }\r
1901         if (genTOBuilders !== null && !genTOBuilders.isEmpty()) {\r
1902             for (genTOBuilder : genTOBuilders) {\r
1903                 typeBuilder.addEnclosingTransferObject(genTOBuilder);\r
1904             }\r
1905             return genTOBuilders.get(0);\r
1906         }\r
1907         return null;\r
1908 \r
1909     }\r
1910 \r
1911     /**\r
1912      * Adds the implemented types to type builder.\r
1913      *\r
1914      * The method passes through the list of <i>uses</i> in\r
1915      * {@code dataNodeContainer}. For every <i>use</i> is obtained coresponding\r
1916      * generated type from {@link BindingGeneratorImpl#allGroupings\r
1917      * allGroupings} which is added as <i>implements type</i> to\r
1918      * <code>builder</code>\r
1919      *\r
1920      * @param dataNodeContainer\r
1921      *            element which contains the list of used YANG groupings\r
1922      * @param builder\r
1923      *            builder to which are added implemented types according to\r
1924      *            <code>dataNodeContainer</code>\r
1925      * @return generated type builder with all implemented types\r
1926      */\r
1927     private def addImplementedInterfaceFromUses( DataNodeContainer dataNodeContainer,\r
1928             GeneratedTypeBuilder builder) {\r
1929         for (usesNode : dataNodeContainer.uses) {\r
1930             if (usesNode.groupingPath !== null) {\r
1931                 val genType = allGroupings.get(usesNode.groupingPath);\r
1932                 if (genType === null) {\r
1933                     throw new IllegalStateException("Grouping " + usesNode.groupingPath + "is not resolved for "\r
1934                             + builder.name);\r
1935                 }\r
1936                 builder.addImplementsType(genType);\r
1937             }\r
1938         }\r
1939         return builder;\r
1940     }\r
1941 }\r