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

   1
   2 /*\r
   3  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.\r
   4  *\r
   5  * This program and the accompanying materials are made available under the\r
   6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   7  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   8  */\r
   9 package org.opendaylight.yangtools.sal.binding.generator.impl;\r
  10 \r
  11 import java.util.ArrayList;\r
  12 import java.util.Collections;\r
  13 import java.util.HashMap;\r
  14 import java.util.List;\r
  15 import java.util.Map;\r
  16 import java.util.Set;\r
  17 import org.opendaylight.yangtools.binding.generator.util.BindingTypes;\r
  18 import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;\r
  19 import org.opendaylight.yangtools.binding.generator.util.Types;\r
  20 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;\r
  21 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;\r
  22 import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;\r
  23 import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;\r
  24 import org.opendaylight.yangtools.sal.binding.model.api.AccessModifier;\r
  25 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;\r
  26 import org.opendaylight.yangtools.sal.binding.model.api.Type;\r
  27 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;\r
  28 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;\r
  29 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;\r
  30 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;\r
  31 import org.opendaylight.yangtools.sal.binding.yang.types.GroupingDefinitionDependencySort;\r
  32 import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl;\r
  33 import org.opendaylight.yangtools.yang.binding.RpcService;\r
  34 import org.opendaylight.yangtools.yang.common.RpcResult;\r
  35 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;\r
  36 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;\r
  37 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;\r
  38 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;\r
  39 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;\r
  40 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;\r
  41 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;\r
  42 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;\r
  43 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;\r
  44 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;\r
  45 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;\r
  46 import org.opendaylight.yangtools.yang.model.api.Module;\r
  47 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;\r
  48 import org.opendaylight.yangtools.yang.model.api.SchemaContext;\r
  49 import org.opendaylight.yangtools.yang.model.api.SchemaNode;\r
  50 import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
  51 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;\r
  52 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;\r
  53 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;\r
  54 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;\r
  55 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;\r
  56 import org.opendaylight.yangtools.yang.model.util.DataNodeIterator;\r
  57 import org.opendaylight.yangtools.yang.model.util.ExtendedType;\r
  58 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;\r
  59 import org.opendaylight.yangtools.yang.model.util.UnionType;\r
  60 import static com.google.common.base.Preconditions.*;\r
  61 import static extension org.opendaylight.yangtools.binding.generator.util.Types.*;\r
  62 import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.*;
  63 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.*;
  64 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*;
  65
  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 = new 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         val List<Type> genTypes = new ArrayList();\r
 880         // EVERY augmented interface will extends Augmentation<T> interface\r
 881         // and DataObject interface!!!\r
 882         val targetPath = augSchema.targetPath;\r
 883         val targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);\r
 884         var targetType = yangToJavaMapping.get(targetSchemaNode.path);\r
 885         if(targetType == null) {\r
 886             // FIXME: augmentation should be added as last, all types should already be generated\r
 887             // and have assigned Java Types,\r
 888             val targetModule = findParentModule(schemaContext, targetSchemaNode);\r
 889             val targetBasePackage = moduleNamespaceToPackageName(targetModule);\r
 890             val typePackage = packageNameForGeneratedType(targetBasePackage, targetSchemaNode.getPath());\r
 891             val targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();\r
 892             val typeName = parseToClassName(targetSchemaNodeName);\r
 893             targetType = new ReferencedTypeImpl(typePackage,typeName);\r
 894         }\r
 895         if (targetSchemaNode !== null) {\r
 896             val augChildNodes = augSchema.childNodes;\r
 897             if (!(targetSchemaNode instanceof ChoiceNode)) {\r
 898                 val augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName,\r
 899                         targetType, augSchema);\r
 900                 val augType = augTypeBuilder.toInstance();\r
 901                 genTypes.add(augType);\r
 902             } else {\r
 903                 val choiceTarget = targetSchemaNode as ChoiceNode;\r
 904                 val choiceCaseNodes = choiceTarget.cases;\r
 905                 genTypes.addAll(generateTypesFromAugmentedChoiceCases(augmentPackageName, targetType,\r
 906                         choiceCaseNodes));\r
 907             }\r
 908             genTypes.addAll(augmentationBodyToGenTypes(augmentPackageName, augChildNodes));\r
 909         }\r
 910         return genTypes;\r
 911     }\r
 912 \r
 913     /**\r
 914      * Returns a generated type builder for an augmentation.\r
 915      *\r
 916      * The name of the type builder is equal to the name of augmented node with\r
 917      * serial number as suffix.\r
 918      *\r
 919      * @param augmentPackageName\r
 920      *            string with contains the package name to which the augment\r
 921      *            belongs\r
 922      * @param targetPackageName\r
 923      *            string with the package name to which the augmented node\r
 924      *            belongs\r
 925      * @param targetSchemaNodeName\r
 926      *            string with the name of the augmented node\r
 927      * @param augSchema\r
 928      *            augmentation schema which contains data about the child nodes\r
 929      *            and uses of augment\r
 930      * @return generated type builder for augment\r
 931      */\r
 932     private def GeneratedTypeBuilder addRawAugmentGenTypeDefinition( String augmentPackageName,\r
 933             Type targetTypeRef, AugmentationSchema augSchema) {\r
 934         var Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);\r
 935         if (augmentBuilders === null) {\r
 936             augmentBuilders = new HashMap();\r
 937             genTypeBuilders.put(augmentPackageName, augmentBuilders);\r
 938         }\r
 939         val augIdentifier = getAugmentIdentifier(augSchema.unknownSchemaNodes);\r
 940 \r
 941         val augTypeName = if (augIdentifier !== null ) { \r
 942             parseToClassName(augIdentifier)\r
 943         } else {\r
 944             augGenTypeName(augmentBuilders, targetTypeRef.name);\r
 945         }\r
 946         val Set<DataSchemaNode> augChildNodes = augSchema.childNodes;\r
 947 \r
 948         val augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);\r
 949 \r
 950         augTypeBuilder.addImplementsType(DATA_OBJECT);\r
 951         augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));\r
 952         addImplementedInterfaceFromUses(augSchema, augTypeBuilder);\r
 953 \r
 954         augSchemaNodeToMethods(augmentPackageName, augTypeBuilder, augChildNodes);\r
 955         augmentBuilders.put(augTypeName, augTypeBuilder);\r
 956         return augTypeBuilder;\r
 957     }\r
 958 \r
 959     /**\r
 960      *\r
 961      * @param unknownSchemaNodes\r
 962      * @return\r
 963      */\r
 964     private def String getAugmentIdentifier(List<UnknownSchemaNode> unknownSchemaNodes) {\r
 965         for (unknownSchemaNode : unknownSchemaNodes) {\r
 966             val nodeType = unknownSchemaNode.nodeType;\r
 967             if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.localName)\r
 968                     && YANG_EXT_NAMESPACE.equals(nodeType.namespace.toString())) {\r
 969                 return unknownSchemaNode.nodeParameter;\r
 970             }\r
 971         }\r
 972         return null;\r
 973     }\r
 974 \r
 975     /**\r
 976      * Convert a container, list and choice subnodes (and recursivelly their\r
 977      * subnodes) of augment to generated types\r
 978      *\r
 979      * @param augBasePackageName\r
 980      *            string with the augment package name\r
 981      * @param augChildNodes\r
 982      *            set of data schema nodes which represents child nodes of the\r
 983      *            augment\r
 984      *\r
 985      * @return list of <code>Type</code> which represents container, list and\r
 986      *         choice subnodes of augment\r
 987      */\r
 988     private def List<Type> augmentationBodyToGenTypes( String augBasePackageName,\r
 989             Set<DataSchemaNode> augChildNodes) {\r
 990         val List<Type> genTypes = new ArrayList();\r
 991         val List<DataNodeIterator> augSchemaIts = new ArrayList();\r
 992         for (childNode : augChildNodes) {\r
 993             if (childNode instanceof DataNodeContainer) {\r
 994                 augSchemaIts.add(new DataNodeIterator(childNode as DataNodeContainer));\r
 995 \r
 996                 if (childNode instanceof ContainerSchemaNode) {\r
 997                     genTypes.add(containerToGenType(augBasePackageName, childNode as ContainerSchemaNode));\r
 998                 } else if (childNode instanceof ListSchemaNode) {\r
 999                     genTypes.addAll(listToGenType(augBasePackageName, childNode as ListSchemaNode));\r
1000                 }\r
1001             } else if (childNode instanceof ChoiceNode) {\r
1002                 val choice = childNode as ChoiceNode;\r
1003                 for (caseNode : choice.cases) {\r
1004                     augSchemaIts.add(new DataNodeIterator(caseNode));\r
1005                 }\r
1006                 genTypes.addAll(choiceToGeneratedType(augBasePackageName, childNode as ChoiceNode));\r
1007             }\r
1008         }\r
1009 \r
1010         for (it : augSchemaIts) {\r
1011             val List<ContainerSchemaNode> augContainers = it.allContainers();\r
1012             val List<ListSchemaNode> augLists = it.allLists();\r
1013             val List<ChoiceNode> augChoices = it.allChoices();\r
1014 \r
1015             if (augContainers !== null) {\r
1016                 for (container : augContainers) {\r
1017                     genTypes.add(containerToGenType(augBasePackageName, container));\r
1018                 }\r
1019             }\r
1020             if (augLists !== null) {\r
1021                 for (list : augLists) {\r
1022                     genTypes.addAll(listToGenType(augBasePackageName, list));\r
1023                 }\r
1024             }\r
1025             if (augChoices !== null) {\r
1026                 for (choice : augChoices) {\r
1027                     genTypes.addAll(choiceToGeneratedType(augBasePackageName, choice));\r
1028                 }\r
1029             }\r
1030         }\r
1031         return genTypes;\r
1032     }\r
1033 \r
1034     /**\r
1035      * Returns first unique name for the augment generated type builder. The\r
1036      * generated type builder name for augment consists from name of augmented\r
1037      * node and serial number of its augmentation.\r
1038      *\r
1039      * @param builders\r
1040      *            map of builders which were created in the package to which the\r
1041      *            augmentation belongs\r
1042      * @param genTypeName\r
1043      *            string with name of augmented node\r
1044      * @return string with unique name for augmentation builder\r
1045      */\r
1046     private def String augGenTypeName( Map<String, GeneratedTypeBuilder> builders, String genTypeName) {\r
1047         var index = 1;\r
1048         while ((builders !== null) && builders.containsKey(genTypeName + index)) {\r
1049             index = index + 1;\r
1050         }\r
1051         return genTypeName + index;\r
1052     }\r
1053 \r
1054     /**\r
1055      * Converts <code>containerNode</code> to generated type. Firstly the\r
1056      * generated type builder is created. The subnodes of\r
1057      * <code>containerNode</code> are added as methods and the instance of\r
1058      * <code>GeneratedType</code> is returned.\r
1059      *\r
1060      * @param basePackageName\r
1061      *            string contains the module package name\r
1062      * @param containerNode\r
1063      *            container schema node with the data about childs nodes and\r
1064      *            schema paths\r
1065      * @return generated type for <code>containerNode</code>\r
1066      */\r
1067     private def GeneratedType containerToGenType( String basePackageName, ContainerSchemaNode containerNode) {\r
1068         if (containerNode === null) {\r
1069             return null;\r
1070         }\r
1071 \r
1072         val packageName = packageNameForGeneratedType(basePackageName, containerNode.path);\r
1073         val schemaNodes = containerNode.childNodes;\r
1074         val typeBuilder = addDefaultInterfaceDefinition(packageName, containerNode);\r
1075 \r
1076         resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
1077         return typeBuilder.toInstance();\r
1078     }\r
1079 \r
1080     /**\r
1081      * Adds the methods to <code>typeBuilder</code> which represent subnodes of\r
1082      * node for which <code>typeBuilder</code> was created.\r
1083      *\r
1084      * The subnodes aren't mapped to the methods if they are part of grouping or\r
1085      * augment (in this case are already part of them).\r
1086      *\r
1087      * @param basePackageName\r
1088      *            string contains the module package name\r
1089      * @param typeBuilder\r
1090      *            generated type builder which represents any node. The subnodes\r
1091      *            of this node are added to the <code>typeBuilder</code> as\r
1092      *            methods. The subnode can be of type leaf, leaf-list, list,\r
1093      *            container, choice.\r
1094      * @param schemaNodes\r
1095      *            set of data schema nodes which are the children of the node\r
1096      *            for which <code>typeBuilder</code> was created\r
1097      * @return generated type builder which is the same builder as input\r
1098      *         parameter. The getter methods (representing child nodes) could be\r
1099      *         added to it.\r
1100      */\r
1101     private def GeneratedTypeBuilder resolveDataSchemaNodes( String basePackageName,\r
1102             GeneratedTypeBuilder typeBuilder, Set<DataSchemaNode> schemaNodes) {\r
1103         if ((schemaNodes !== null) && (typeBuilder !== null)) {\r
1104             for (schemaNode : schemaNodes) {\r
1105                 if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {\r
1106                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
1107                 }\r
1108                 \r
1109             }\r
1110         }\r
1111         return typeBuilder;\r
1112     }\r
1113 \r
1114     /**\r
1115      * Adds the methods to <code>typeBuilder</code> what represents subnodes of\r
1116      * node for which <code>typeBuilder</code> was created.\r
1117      *\r
1118      * @param basePackageName\r
1119      *            string contains the module package name\r
1120      * @param typeBuilder\r
1121      *            generated type builder which represents any node. The subnodes\r
1122      *            of this node are added to the <code>typeBuilder</code> as\r
1123      *            methods. The subnode can be of type leaf, leaf-list, list,\r
1124      *            container, choice.\r
1125      * @param schemaNodes\r
1126      *            set of data schema nodes which are the children of the node\r
1127      *            for which <code>typeBuilder</code> was created\r
1128      * @return generated type builder which is the same object as the input\r
1129      *         parameter <code>typeBuilder</code>. The getter method could be\r
1130      *         added to it.\r
1131      */\r
1132     private def GeneratedTypeBuilder augSchemaNodeToMethods( String basePackageName,\r
1133              GeneratedTypeBuilder typeBuilder,  Set<DataSchemaNode> schemaNodes) {\r
1134         if ((schemaNodes !== null) && (typeBuilder !== null)) {\r
1135             for (schemaNode : schemaNodes) {\r
1136                 if (schemaNode.isAugmenting()) {\r
1137                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
1138                 }\r
1139             }\r
1140         }\r
1141         return typeBuilder;\r
1142     }\r
1143 \r
1144     /**\r
1145      * Adds to <code>typeBuilder</code> a method which is derived from\r
1146      * <code>schemaNode</code>.\r
1147      *\r
1148      * @param basePackageName\r
1149      *            string with the module package name\r
1150      * @param schemaNode\r
1151      *            data schema node which is added to <code>typeBuilder</code> as\r
1152      *            a method\r
1153      * @param typeBuilder\r
1154      *            generated type builder to which is <code>schemaNode</code>\r
1155      *            added as a method.\r
1156      */\r
1157     private def void addSchemaNodeToBuilderAsMethod( String basePackageName,  DataSchemaNode node,\r
1158              GeneratedTypeBuilder typeBuilder) {\r
1159         if (node !== null && typeBuilder !== null) {\r
1160             switch(node) {\r
1161                 case node instanceof LeafSchemaNode: resolveLeafSchemaNodeAsMethod(typeBuilder, node as LeafSchemaNode)\r
1162                 case node instanceof LeafListSchemaNode: resolveLeafListSchemaNode(typeBuilder, node as LeafListSchemaNode)\r
1163                 case node instanceof ContainerSchemaNode: resolveContainerSchemaNode(basePackageName, typeBuilder, node as ContainerSchemaNode)\r
1164                 case node instanceof ListSchemaNode: resolveListSchemaNode(basePackageName, typeBuilder, node as ListSchemaNode)\r
1165                 case node instanceof ChoiceNode: resolveChoiceSchemaNode(basePackageName, typeBuilder, node as ChoiceNode)\r
1166             }\r
1167         }\r
1168     }\r
1169 \r
1170     /**\r
1171      * Creates a getter method for a choice node.\r
1172      *\r
1173      * Firstly generated type builder for choice is created or found in\r
1174      * {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name\r
1175      * in the builder is created as concatenation of module package name and\r
1176      * names of all parent nodes. In the end the getter method for choice is\r
1177      * added to <code>typeBuilder</code> and return type is set to choice\r
1178      * builder.\r
1179      *\r
1180      * @param basePackageName\r
1181      *            string with the module package name\r
1182      * @param typeBuilder\r
1183      *            generated type builder to which is <code>choiceNode</code>\r
1184      *            added as getter method\r
1185      * @param choiceNode\r
1186      *            choice node which is mapped as a getter method\r
1187      * @throws IllegalArgumentException\r
1188      *             <ul>\r
1189      *             <li>if <code>basePackageName</code> equals null</li>\r
1190      *             <li>if <code>typeBuilder</code> equals null</li>\r
1191      *             <li>if <code>choiceNode</code> equals null</li>\r
1192      *             </ul>\r
1193      *\r
1194      */\r
1195     private def void resolveChoiceSchemaNode( String basePackageName,  GeneratedTypeBuilder typeBuilder,\r
1196              ChoiceNode choiceNode) {\r
1197         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1198         checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
1199         checkArgument(choiceNode !== null,"Choice Schema Node cannot be NULL.");\r
1200 \r
1201         val choiceName = choiceNode.QName.localName;\r
1202         if (choiceName !== null && !choiceNode.isAddedByUses()) {\r
1203             val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);\r
1204             val choiceType = addDefaultInterfaceDefinition(packageName, choiceNode);\r
1205             constructGetter(typeBuilder, choiceName, choiceNode.description, choiceType);\r
1206         }\r
1207     }\r
1208 \r
1209     /**\r
1210      * Converts <code>choiceNode</code> to the list of generated types for\r
1211      * choice and its cases.\r
1212      *\r
1213      * The package names for choice and for its cases are created as\r
1214      * concatenation of the module package (<code>basePackageName</code>) and\r
1215      * names of all parents node.\r
1216      *\r
1217      * @param basePackageName\r
1218      *            string with the module package name\r
1219      * @param choiceNode\r
1220      *            choice node which is mapped to generated type. Also child\r
1221      *            nodes - cases are mapped to generated types.\r
1222      * @return list of generated types which contains generated type for choice\r
1223      *         and generated types for all cases which aren't added do choice\r
1224      *         through <i>uses</i>.\r
1225      * @throws IllegalArgumentException\r
1226      *             <ul>\r
1227      *             <li>if <code>basePackageName</code> equals null</li>\r
1228      *             <li>if <code>choiceNode</code> equals null</li>\r
1229      *             </ul>\r
1230      *\r
1231      */\r
1232     private def List<GeneratedType> choiceToGeneratedType( String basePackageName,  ChoiceNode choiceNode) {\r
1233         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1234         checkArgument(choiceNode !== null,"Choice Schema Node cannot be NULL.");\r
1235 \r
1236         val List<GeneratedType> generatedTypes = new ArrayList();\r
1237         val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);\r
1238         val choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);\r
1239         //choiceTypeBuilder.addImplementsType(DATA_OBJECT);\r
1240         val choiceType = choiceTypeBuilder.toInstance();\r
1241 \r
1242         generatedTypes.add(choiceType);\r
1243         val Set<ChoiceCaseNode> caseNodes = choiceNode.cases;\r
1244         if ((caseNodes !== null) && !caseNodes.isEmpty()) {\r
1245             generatedTypes.addAll(generateTypesFromChoiceCases(basePackageName, choiceType, caseNodes));\r
1246         }\r
1247         return generatedTypes;\r
1248     }\r
1249 \r
1250     /**\r
1251      * Converts <code>caseNodes</code> set to list of corresponding generated\r
1252      * types.\r
1253      *\r
1254      * For every <i>case</i> which isn't added through augment or <i>uses</i> is\r
1255      * created generated type builder. The package names for the builder is\r
1256      * created as concatenation of the module package (\r
1257      * <code>basePackageName</code>) and names of all parents nodes of the\r
1258      * concrete <i>case</i>. There is also relation "<i>implements type</i>"\r
1259      * between every case builder and <i>choice</i> type\r
1260      *\r
1261      * @param basePackageName\r
1262      *            string with the module package name\r
1263      * @param refChoiceType\r
1264      *            type which represents superior <i>case</i>\r
1265      * @param caseNodes\r
1266      *            set of choice case nodes which are mapped to generated types\r
1267      * @return list of generated types for <code>caseNodes</code>.\r
1268      * @throws IllegalArgumentException\r
1269      *             <ul>\r
1270      *             <li>if <code>basePackageName</code> equals null</li>\r
1271      *             <li>if <code>refChoiceType</code> equals null</li>\r
1272      *             <li>if <code>caseNodes</code> equals null</li>\r
1273      *             </ul>\r
1274      *             *\r
1275      */\r
1276     private def List<GeneratedType> generateTypesFromChoiceCases( String basePackageName,  Type refChoiceType,\r
1277              Set<ChoiceCaseNode> caseNodes) {\r
1278         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1279         checkArgument(refChoiceType !== null,"Referenced Choice Type cannot be NULL.");\r
1280         checkArgument(caseNodes !== null,"Set of Choice Case Nodes cannot be NULL.");\r
1281 \r
1282         val List<GeneratedType> generatedTypes = new ArrayList();\r
1283         for (caseNode : caseNodes) {\r
1284             if (caseNode !== null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {\r
1285                 val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
1286                 val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
1287                 caseTypeBuilder.addImplementsType(refChoiceType);\r
1288 \r
1289                 val Set<DataSchemaNode> childNodes = caseNode.childNodes;\r
1290                 if (childNodes !== null) {\r
1291                     resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);\r
1292                 }\r
1293                 generatedTypes.add(caseTypeBuilder.toInstance());\r
1294             }\r
1295         }\r
1296 \r
1297         return generatedTypes;\r
1298     }\r
1299 \r
1300     /**\r
1301      * Generates list of generated types for all the cases of a choice which are\r
1302      * added to the choice through the augment.\r
1303      *\r
1304      *\r
1305      * @param basePackageName\r
1306      *            string contains name of package to which augment belongs. If\r
1307      *            an augmented choice is from an other package (pcg1) than an\r
1308      *            augmenting choice (pcg2) then case's of the augmenting choice\r
1309      *            will belong to pcg2.\r
1310      * @param refChoiceType\r
1311      *            Type which represents the choice to which case belongs. Every\r
1312      *            case has to contain its choice in extend part.\r
1313      * @param caseNodes\r
1314      *            set of choice case nodes for which is checked if are/aren't\r
1315      *            added to choice through augmentation\r
1316      * @return list of generated types which represents augmented cases of\r
1317      *         choice <code>refChoiceType</code>\r
1318      * @throws IllegalArgumentException\r
1319      *             <ul>\r
1320      *             <li>if <code>basePackageName</code> equals null</li>\r
1321      *             <li>if <code>refChoiceType</code> equals null</li>\r
1322      *             <li>if <code>caseNodes</code> equals null</li>\r
1323      *             </ul>\r
1324      */\r
1325     private def List<GeneratedType> generateTypesFromAugmentedChoiceCases( String basePackageName,\r
1326              Type refChoiceType,  Set<ChoiceCaseNode> caseNodes) {\r
1327         checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
1328         checkArgument(refChoiceType !== null,"Referenced Choice Type cannot be NULL.");\r
1329         checkArgument(caseNodes !== null,"Set of Choice Case Nodes cannot be NULL.");\r
1330 \r
1331         val List<GeneratedType> generatedTypes = new ArrayList();\r
1332         for (caseNode : caseNodes) {\r
1333             if (caseNode !== null && caseNode.isAugmenting()) {\r
1334                 val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
1335                 val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
1336                 caseTypeBuilder.addImplementsType(refChoiceType);\r
1337 \r
1338                 val Set<DataSchemaNode> childNodes = caseNode.childNodes;\r
1339                 if (childNodes !== null) {\r
1340                     resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);\r
1341                 }\r
1342                 generatedTypes.add(caseTypeBuilder.toInstance());\r
1343             }\r
1344         }\r
1345 \r
1346         return generatedTypes;\r
1347     }\r
1348 \r
1349     /**\r
1350      * Converts <code>leaf</code> to the getter method which is added to\r
1351      * <code>typeBuilder</code>.\r
1352      *\r
1353      * @param typeBuilder\r
1354      *            generated type builder to which is added getter method as\r
1355      *            <code>leaf</code> mapping\r
1356      * @param leaf\r
1357      *            leaf schema node which is mapped as getter method which is\r
1358      *            added to <code>typeBuilder</code>\r
1359      * @return boolean value\r
1360      *         <ul>\r
1361      *         <li>false - if <code>leaf</code> or <code>typeBuilder</code> are\r
1362      *         null</li>\r
1363      *         <li>true - in other cases</li>\r
1364      *         </ul>\r
1365      */\r
1366     private def boolean resolveLeafSchemaNodeAsMethod( GeneratedTypeBuilder typeBuilder,  LeafSchemaNode leaf) {\r
1367         if ((leaf !== null) && (typeBuilder !== null)) {\r
1368             val leafName = leaf.QName.localName;\r
1369             var String leafDesc = leaf.description;\r
1370             if (leafDesc === null) {\r
1371                 leafDesc = "";\r
1372             }\r
1373 \r
1374             val parentModule = findParentModule(schemaContext, leaf);\r
1375             if (leafName !== null && !leaf.isAddedByUses()) {\r
1376                 val TypeDefinition<?> typeDef = leaf.type;\r
1377 \r
1378                 var Type returnType = null;\r
1379                 if (typeDef instanceof EnumTypeDefinition) {\r
1380                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
1381                     val enumTypeDef = enumTypeDefFromExtendedType(typeDef);\r
1382                     val enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leafName,\r
1383                             typeBuilder);\r
1384 \r
1385                     if (enumBuilder !== null) {\r
1386                         returnType = new ReferencedTypeImpl(enumBuilder.packageName, enumBuilder.name);\r
1387                     }\r
1388                     (typeProvider as TypeProviderImpl).putReferencedType(leaf.path, returnType);\r
1389                 } else if (typeDef instanceof UnionType) {\r
1390                     val genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
1391                     if (genTOBuilder !== null) {\r
1392                         returnType = new ReferencedTypeImpl(genTOBuilder.packageName, genTOBuilder.name);\r
1393                     }\r
1394                 } else if (typeDef instanceof BitsTypeDefinition) {\r
1395                     val genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
1396                     if (genTOBuilder !== null) {\r
1397                         returnType = new ReferencedTypeImpl(genTOBuilder.packageName, genTOBuilder.name);\r
1398                     }\r
1399                 } else {\r
1400                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
1401                 }\r
1402                 if (returnType !== null) {\r
1403                     constructGetter(typeBuilder, leafName, leafDesc, returnType);\r
1404                     return true;\r
1405                 }\r
1406             }\r
1407         }\r
1408         return false;\r
1409     }\r
1410 \r
1411     /**\r
1412      * Converts <code>leaf</code> schema node to property of generated TO\r
1413      * builder.\r
1414      *\r
1415      * @param toBuilder\r
1416      *            generated TO builder to which is <code>leaf</code> added as\r
1417      *            property\r
1418      * @param leaf\r
1419      *            leaf schema node which is added to <code>toBuilder</code> as\r
1420      *            property\r
1421      * @param isReadOnly\r
1422      *            boolean value which says if leaf property is|isn't read only\r
1423      * @return boolean value\r
1424      *         <ul>\r
1425      *         <li>false - if <code>leaf</code>, <code>toBuilder</code> or leaf\r
1426      *         name equals null or if leaf is added by <i>uses</i>.</li>\r
1427      *         <li>true - other cases</li>\r
1428      *         </ul>\r
1429      */\r
1430     private def boolean resolveLeafSchemaNodeAsProperty( GeneratedTOBuilder toBuilder, LeafSchemaNode leaf,\r
1431             boolean isReadOnly) {\r
1432         if ((leaf !== null) && (toBuilder !== null)) {\r
1433             val leafName = leaf.QName.localName;\r
1434             var String leafDesc = leaf.description;\r
1435             if (leafDesc === null) {\r
1436                 leafDesc = "";\r
1437             }\r
1438 \r
1439             if (leafName !== null && !leaf.isAddedByUses()) {\r
1440                 val TypeDefinition<?> typeDef = leaf.type;\r
1441 \r
1442                 // TODO: properly resolve enum types\r
1443                 val returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
1444 \r
1445                 if (returnType !== null) {\r
1446                     val propBuilder = toBuilder.addProperty(parseToClassName(leafName));\r
1447 \r
1448                     propBuilder.setReadOnly(isReadOnly);\r
1449                     propBuilder.setReturnType(returnType);\r
1450                     propBuilder.setComment(leafDesc);\r
1451 \r
1452                     toBuilder.addEqualsIdentity(propBuilder);\r
1453                     toBuilder.addHashIdentity(propBuilder);\r
1454                     toBuilder.addToStringProperty(propBuilder);\r
1455 \r
1456                     return true;\r
1457                 }\r
1458             }\r
1459         }\r
1460         return false;\r
1461     }\r
1462 \r
1463     /**\r
1464      * Converts <code>node</code> leaf list schema node to getter method of\r
1465      * <code>typeBuilder</code>.\r
1466      *\r
1467      * @param typeBuilder\r
1468      *            generated type builder to which is <code>node</code> added as\r
1469      *            getter method\r
1470      * @param node\r
1471      *            leaf list schema node which is added to\r
1472      *            <code>typeBuilder</code> as getter method\r
1473      * @return boolean value\r
1474      *         <ul>\r
1475      *         <li>true - if <code>node</code>, <code>typeBuilder</code>,\r
1476      *         nodeName equal null or <code>node</code> is added by <i>uses</i></li>\r
1477      *         <li>false - other cases</li>\r
1478      *         </ul>\r
1479      */\r
1480     private def boolean resolveLeafListSchemaNode( GeneratedTypeBuilder typeBuilder, LeafListSchemaNode node) {\r
1481         if ((node !== null) && (typeBuilder !== null)) {\r
1482             val nodeName = node.QName.localName;\r
1483             var String nodeDesc = node.description;\r
1484             if (nodeDesc === null) {\r
1485                 nodeDesc = "";\r
1486             }\r
1487 \r
1488             if (nodeName !== null && !node.isAddedByUses()) {\r
1489                 val TypeDefinition<?> type = node.type;\r
1490                 val listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type, node));\r
1491 \r
1492                 constructGetter(typeBuilder, nodeName, nodeDesc, listType);\r
1493                 return true;\r
1494             }\r
1495         }\r
1496         return false;\r
1497     }\r
1498 \r
1499     /**\r
1500      * Creates a getter method for a container node.\r
1501      *\r
1502      * Firstly generated type builder for container is created or found in\r
1503      * {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name\r
1504      * in the builder is created as concatenation of module package name and\r
1505      * names of all parent nodes. In the end the getter method for container is\r
1506      * added to <code>typeBuilder</code> and return type is set to container\r
1507      * type builder.\r
1508      *\r
1509      * @param basePackageName\r
1510      *            string with the module package name\r
1511      * @param typeBuilder\r
1512      *            generated type builder to which is <code>containerNode</code>\r
1513      *            added as getter method\r
1514      * @param containerNode\r
1515      *            container schema node which is mapped as getter method to\r
1516      *            <code>typeBuilder</code>\r
1517      * @return boolean value\r
1518      *         <ul>\r
1519      *         <li>false - if <code>containerNode</code>,\r
1520      *         <code>typeBuilder</code>, container node name equal null or\r
1521      *         <code>containerNode</code> is added by uses</li>\r
1522      *         <li>true - other cases</li>\r
1523      *         </ul>\r
1524      */\r
1525     private def boolean resolveContainerSchemaNode( String basePackageName, GeneratedTypeBuilder typeBuilder,\r
1526             ContainerSchemaNode containerNode) {\r
1527         if ((containerNode !== null) && (typeBuilder !== null)) {\r
1528             val nodeName = containerNode.QName.localName;\r
1529 \r
1530             if (nodeName !== null && !containerNode.isAddedByUses()) {\r
1531                 val packageName = packageNameForGeneratedType(basePackageName, containerNode.path);\r
1532 \r
1533                 val rawGenType = addDefaultInterfaceDefinition(packageName, containerNode);\r
1534                 constructGetter(typeBuilder, nodeName, containerNode.description, rawGenType);\r
1535 \r
1536                 return true;\r
1537             }\r
1538         }\r
1539         return false;\r
1540     }\r
1541 \r
1542     /**\r
1543      * Creates a getter method for a list node.\r
1544      *\r
1545      * Firstly generated type builder for list is created or found in\r
1546      * {@link BindingGeneratorImpl#allGroupings allGroupings}. The package name\r
1547      * in the builder is created as concatenation of module package name and\r
1548      * names of all parent nodes. In the end the getter method for list is added\r
1549      * to <code>typeBuilder</code> and return type is set to list type builder.\r
1550      *\r
1551      * @param basePackageName\r
1552      *            string with the module package name\r
1553      * @param typeBuilder\r
1554      *            generated type builder to which is <code></code> added as\r
1555      *            getter method\r
1556      * @param listNode\r
1557      *            list schema node which is mapped as getter method to\r
1558      *            <code>typeBuilder</code>\r
1559      * @return boolean value\r
1560      *         <ul>\r
1561      *         <li>false - if <code>listNode</code>, <code>typeBuilder</code>,\r
1562      *         list node name equal null or <code>listNode</code> is added by\r
1563      *         uses</li>\r
1564      *         <li>true - other cases</li>\r
1565      *         </ul>\r
1566      */\r
1567     private def boolean resolveListSchemaNode( String basePackageName, GeneratedTypeBuilder typeBuilder,\r
1568             ListSchemaNode listNode) {\r
1569         if ((listNode !== null) && (typeBuilder !== null)) {\r
1570             val listName = listNode.QName.localName;\r
1571 \r
1572             if (listName !== null && !listNode.isAddedByUses()) {\r
1573                 val packageName = packageNameForGeneratedType(basePackageName, listNode.path);\r
1574                 val rawGenType = addDefaultInterfaceDefinition(packageName, listNode);\r
1575                 constructGetter(typeBuilder, listName, listNode.description, Types.listTypeFor(rawGenType));\r
1576                 return true;\r
1577             }\r
1578         }\r
1579         return false;\r
1580     }\r
1581 \r
1582     /**\r
1583      * Instantiates generated type builder with <code>packageName</code> and\r
1584      * <code>schemaNode</code>.\r
1585      *\r
1586      * The new builder always implements\r
1587      * {@link org.opendaylight.yangtools.yang.binding.DataObject DataObject}.<br />\r
1588      * If <code>schemaNode</code> is instance of GroupingDefinition it also\r
1589      * implements {@link org.opendaylight.yangtools.yang.binding.Augmentable\r
1590      * Augmentable}.<br />\r
1591      * If <code>schemaNode</code> is instance of\r
1592      * {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer\r
1593      * DataNodeContainer} it can also implement nodes which are specified in\r
1594      * <i>uses</i>.\r
1595      *\r
1596      * @param packageName\r
1597      *            string with the name of the package to which\r
1598      *            <code>schemaNode</code> belongs.\r
1599      * @param schemaNode\r
1600      *            schema node for which is created generated type builder\r
1601      * @return generated type builder <code>schemaNode</code>\r
1602      */\r
1603     private def GeneratedTypeBuilder addDefaultInterfaceDefinition( String packageName, SchemaNode schemaNode) {\r
1604         val builder = addRawInterfaceDefinition(packageName, schemaNode, "");\r
1605         builder.addImplementsType(DATA_OBJECT);\r
1606         if (!(schemaNode instanceof GroupingDefinition)) {\r
1607             builder.addImplementsType(augmentable(builder));\r
1608         }\r
1609 \r
1610         if (schemaNode instanceof DataNodeContainer) {\r
1611             addImplementedInterfaceFromUses( schemaNode as DataNodeContainer, builder);\r
1612         }\r
1613 \r
1614         return builder;\r
1615     }\r
1616 \r
1617     /**\r
1618      * Wraps the calling of the same overloaded method.\r
1619      *\r
1620      * @param packageName\r
1621      *            string with the package name to which returning generated type\r
1622      *            builder belongs\r
1623      * @param schemaNode\r
1624      *            schema node which provide data about the schema node name\r
1625      * @return generated type builder for <code>schemaNode</code>\r
1626      */\r
1627     private def GeneratedTypeBuilder addRawInterfaceDefinition( String packageName,  SchemaNode schemaNode) {\r
1628         return addRawInterfaceDefinition(packageName, schemaNode, "");\r
1629     }\r
1630 \r
1631     /**\r
1632      * Returns reference to generated type builder for specified\r
1633      * <code>schemaNode</code> with <code>packageName</code>.\r
1634      *\r
1635      * Firstly the generated type builder is searched in\r
1636      * {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't\r
1637      * found it is created and added to <code>genTypeBuilders</code>.\r
1638      *\r
1639      * @param packageName\r
1640      *            string with the package name to which returning generated type\r
1641      *            builder belongs\r
1642      * @param schemaNode\r
1643      *            schema node which provide data about the schema node name\r
1644      * @return generated type builder for <code>schemaNode</code>\r
1645      * @throws IllegalArgumentException\r
1646      *             <ul>\r
1647      *             <li>if <code>schemaNode</code> equals null</li>\r
1648      *             <li>if <code>packageName</code> equals null</li>\r
1649      *             <li>if Q name of schema node is null</li>\r
1650      *             <li>if schema node name is nul</li>\r
1651      *             </ul>\r
1652      *\r
1653      */\r
1654     private def GeneratedTypeBuilder addRawInterfaceDefinition( String packageName,  SchemaNode schemaNode,\r
1655              String prefix) {\r
1656         checkArgument(schemaNode !== null,"Data Schema Node cannot be NULL.");\r
1657         checkArgument(packageName !== null,"Package Name for Generated Type cannot be NULL.");\r
1658         checkArgument(schemaNode.QName !== null,"QName for Data Schema Node cannot be NULL.");\r
1659         val schemaNodeName = schemaNode.QName.localName;\r
1660         checkArgument(schemaNodeName !== null,"Local Name of QName for Data Schema Node cannot be NULL.");\r
1661 \r
1662         var String genTypeName;\r
1663         if (prefix === null) {\r
1664             genTypeName = parseToClassName(schemaNodeName);\r
1665         } else {\r
1666             genTypeName = prefix + parseToClassName(schemaNodeName);\r
1667         }\r
1668         //FIXME: Validation of name conflict\r
1669         val newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);\r
1670         yangToJavaMapping.put(schemaNode.path,newType);\r
1671         if (!genTypeBuilders.containsKey(packageName)) {\r
1672             val Map<String, GeneratedTypeBuilder> builders = new HashMap();\r
1673             builders.put(genTypeName, newType);\r
1674             genTypeBuilders.put(packageName, builders);\r
1675         } else {\r
1676             val Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);\r
1677             if (!builders.containsKey(genTypeName)) {\r
1678                 builders.put(genTypeName, newType);\r
1679             }\r
1680         }\r
1681         return newType;\r
1682     }\r
1683 \r
1684     /**\r
1685      * Creates the name of the getter method from <code>methodName</code>.\r
1686      *\r
1687      * @param methodName\r
1688      *            string with the name of the getter method\r
1689      * @return string with the name of the getter method for\r
1690      *         <code>methodName</code> in JAVA method format\r
1691      */\r
1692     private def String getterMethodName( String methodName,Type returnType) {\r
1693         val method = new StringBuilder();\r
1694         if(BOOLEAN.equals(returnType)) {\r
1695             method.append("is");\r
1696         } else {\r
1697             method.append("get");\r
1698         }\r
1699         method.append(parseToClassName(methodName));\r
1700         return method.toString();\r
1701     }\r
1702 \r
1703     /**\r
1704      * Created a method signature builder as part of\r
1705      * <code>interfaceBuilder</code>.\r
1706      *\r
1707      * The method signature builder is created for the getter method of\r
1708      * <code>schemaNodeName</code>. Also <code>comment</code> and\r
1709      * <code>returnType</code> information are added to the builder.\r
1710      *\r
1711      * @param interfaceBuilder\r
1712      *            generated type builder for which the getter method should be\r
1713      *            created\r
1714      * @param schemaNodeName\r
1715      *            string with schema node name. The name will be the part of the\r
1716      *            getter method name.\r
1717      * @param comment\r
1718      *            string with comment for the getter method\r
1719      * @param returnType\r
1720      *            type which represents the return type of the getter method\r
1721      * @return method signature builder which represents the getter method of\r
1722      *         <code>interfaceBuilder</code>\r
1723      */\r
1724     private def MethodSignatureBuilder constructGetter( GeneratedTypeBuilder interfaceBuilder,\r
1725              String schemaNodeName,  String comment,  Type returnType) {\r
1726 \r
1727         val getMethod = interfaceBuilder.addMethod(getterMethodName(schemaNodeName,returnType));\r
1728 \r
1729         getMethod.setComment(comment);\r
1730         getMethod.setReturnType(returnType);\r
1731 \r
1732         return getMethod;\r
1733     }\r
1734 \r
1735     private def listToGenType( String basePackageName,  ListSchemaNode list) {\r
1736         checkArgument(basePackageName !== null,"Package Name for Generated Type cannot be NULL.");\r
1737         checkArgument(list !== null,"List Schema Node cannot be NULL.");\r
1738 \r
1739         val packageName = packageNameForGeneratedType(basePackageName, list.path);\r
1740         // val typeBuilder =\r
1741         // resolveListTypeBuilder(packageName, list);\r
1742         val typeBuilder = addDefaultInterfaceDefinition(packageName, list);\r
1743 \r
1744         val List<String> listKeys = listKeys(list);\r
1745         val genTOBuilder = resolveListKeyTOBuilder(packageName, list);\r
1746 \r
1747         if (genTOBuilder !== null) {\r
1748             val identifierMarker = IDENTIFIER.parameterizedTypeFor(typeBuilder);\r
1749             val identifiableMarker = IDENTIFIABLE.parameterizedTypeFor(genTOBuilder);\r
1750             genTOBuilder.addImplementsType(identifierMarker);\r
1751             typeBuilder.addImplementsType(identifiableMarker);\r
1752         }\r
1753         val schemaNodes = list.childNodes;\r
1754 \r
1755         for (schemaNode : schemaNodes) {\r
1756             if (!schemaNode.isAugmenting()) {\r
1757                 addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);\r
1758             }\r
1759         }\r
1760         return typeBuildersToGenTypes(typeBuilder, genTOBuilder);\r
1761     }\r
1762 \r
1763     /**\r
1764      * Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method\r
1765      * or to <code>genTOBuilder</code> as property.\r
1766      *\r
1767      * @param basePackageName\r
1768      *            string contains the module package name\r
1769      * @param schemaNode\r
1770      *            data schema node which should be added as getter method to\r
1771      *            <code>typeBuilder</code> or as a property to\r
1772      *            <code>genTOBuilder</code> if is part of the list key\r
1773      * @param typeBuilder\r
1774      *            generated type builder for the list schema node\r
1775      * @param genTOBuilder\r
1776      *            generated TO builder for the list keys\r
1777      * @param listKeys\r
1778      *            list of string which contains names of the list keys\r
1779      * @throws IllegalArgumentException\r
1780      *             <ul>\r
1781      *             <li>if <code>schemaNode</code> equals null</li>\r
1782      *             <li>if <code>typeBuilder</code> equals null</li>\r
1783      *             </ul>\r
1784      */\r
1785     private def void addSchemaNodeToListBuilders( String basePackageName,  DataSchemaNode schemaNode,\r
1786              GeneratedTypeBuilder typeBuilder,  GeneratedTOBuilder genTOBuilder,  List<String> listKeys) {\r
1787         checkArgument(schemaNode !== null,"Data Schema Node cannot be NULL.");\r
1788 \r
1789         checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
1790 \r
1791         if (schemaNode instanceof LeafSchemaNode) {\r
1792             val leaf = schemaNode as LeafSchemaNode;\r
1793             val leafName = leaf.QName.localName;\r
1794             if (!listKeys.contains(leafName)) {\r
1795                 resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);\r
1796             } else {\r
1797                 resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);\r
1798             }\r
1799         } else if (schemaNode instanceof LeafListSchemaNode) {\r
1800             resolveLeafListSchemaNode(typeBuilder,  schemaNode as LeafListSchemaNode);\r
1801         } else if (schemaNode instanceof ContainerSchemaNode) {\r
1802             resolveContainerSchemaNode(basePackageName, typeBuilder, schemaNode as ContainerSchemaNode);\r
1803         } else if (schemaNode instanceof ListSchemaNode) {\r
1804             resolveListSchemaNode(basePackageName, typeBuilder, schemaNode as ListSchemaNode);\r
1805         }\r
1806     }\r
1807 \r
1808     private def typeBuildersToGenTypes( GeneratedTypeBuilder typeBuilder, GeneratedTOBuilder genTOBuilder) {\r
1809         val List<Type> genTypes = new ArrayList();\r
1810         checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
1811 \r
1812         if (genTOBuilder !== null) {\r
1813             val genTO = genTOBuilder.toInstance();\r
1814             constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO);\r
1815             genTypes.add(genTO);\r
1816         }\r
1817         genTypes.add(typeBuilder.toInstance());\r
1818         return genTypes;\r
1819     }\r
1820 \r
1821     /**\r
1822      * Selects the names of the list keys from <code>list</code> and returns\r
1823      * them as the list of the strings\r
1824      *\r
1825      * @param list\r
1826      *            of string with names of the list keys\r
1827      * @return list of string which represents names of the list keys. If the\r
1828      *         <code>list</code> contains no keys then the empty list is\r
1829      *         returned.\r
1830      */\r
1831     private def listKeys( ListSchemaNode list) {\r
1832         val List<String> listKeys = new ArrayList();\r
1833 \r
1834         if (list.keyDefinition !== null) {\r
1835             val keyDefinitions = list.keyDefinition;\r
1836             for (keyDefinition : keyDefinitions) {\r
1837                 listKeys.add(keyDefinition.localName);\r
1838             }\r
1839         }\r
1840         return listKeys;\r
1841     }\r
1842 \r
1843     /**\r
1844      * Generates for the <code>list</code> which contains any list keys special\r
1845      * generated TO builder.\r
1846      *\r
1847      * @param packageName\r
1848      *            string with package name to which the list belongs\r
1849      * @param list\r
1850      *            list schema node which is source of data about the list name\r
1851      * @return generated TO builder which represents the keys of the\r
1852      *         <code>list</code> or null if <code>list</code> is null or list of\r
1853      *         key definitions is null or empty.\r
1854      */\r
1855     private def GeneratedTOBuilder resolveListKeyTOBuilder( String packageName,  ListSchemaNode list) {\r
1856         var GeneratedTOBuilder genTOBuilder = null;\r
1857         if ((list.keyDefinition !== null) && (!list.keyDefinition.isEmpty())) {\r
1858             if (list !== null) {\r
1859                 val listName = list.QName.localName + "Key";\r
1860                 genTOBuilder = schemaNodeToTransferObjectBuilder(packageName, listName);\r
1861             }\r
1862         }\r
1863         return genTOBuilder;\r
1864 \r
1865     }\r
1866 \r
1867     /**\r
1868      * Builds generated TO builders for <code>typeDef</code> of type\r
1869      * {@link org.opendaylight.yangtools.yang.model.util.UnionType UnionType} or\r
1870      * {@link org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition\r
1871      * BitsTypeDefinition} which are also added to <code>typeBuilder</code> as\r
1872      * enclosing transfer object.\r
1873      *\r
1874      * If more then one generated TO builder is created for enclosing then all\r
1875      * of the generated TO builders are added to <code>typeBuilder</code> as\r
1876      * enclosing transfer objects.\r
1877      *\r
1878      * @param typeDef\r
1879      *            type definition which can be of type <code>UnionType</code> or\r
1880      *            <code>BitsTypeDefinition</code>\r
1881      * @param typeBuilder\r
1882      *            generated type builder to which is added generated TO created\r
1883      *            from <code>typeDef</code>\r
1884      * @param leafName\r
1885      *            string with name for generated TO builder\r
1886      * @return generated TO builder for <code>typeDef</code>\r
1887      */\r
1888     private def GeneratedTOBuilder addTOToTypeBuilder(TypeDefinition<?> typeDef, GeneratedTypeBuilder typeBuilder,\r
1889             String leafName, LeafSchemaNode leaf, Module parentModule) {\r
1890         val classNameFromLeaf = parseToClassName(leafName);\r
1891         val List<GeneratedTOBuilder> genTOBuilders = new ArrayList();\r
1892         val packageName = typeBuilder.fullyQualifiedName;\r
1893         if (typeDef instanceof UnionTypeDefinition) {\r
1894             genTOBuilders.addAll((typeProvider as TypeProviderImpl).provideGeneratedTOBuildersForUnionTypeDef(\r
1895                     packageName, typeDef, classNameFromLeaf, leaf));\r
1896         } else if (typeDef instanceof BitsTypeDefinition) {\r
1897             genTOBuilders.add(((typeProvider as TypeProviderImpl) ).provideGeneratedTOBuilderForBitsTypeDefinition(\r
1898                     packageName, typeDef, classNameFromLeaf));\r
1899         }\r
1900         if (genTOBuilders !== null && !genTOBuilders.isEmpty()) {\r
1901             for (genTOBuilder : genTOBuilders) {\r
1902                 typeBuilder.addEnclosingTransferObject(genTOBuilder);\r
1903             }\r
1904             return genTOBuilders.get(0);\r
1905         }\r
1906         return null;\r
1907 \r
1908     }\r
1909 \r
1910     /**\r
1911      * Adds the implemented types to type builder.\r
1912      *\r
1913      * The method passes through the list of <i>uses</i> in\r
1914      * {@code dataNodeContainer}. For every <i>use</i> is obtained coresponding\r
1915      * generated type from {@link BindingGeneratorImpl#allGroupings\r
1916      * allGroupings} which is added as <i>implements type</i> to\r
1917      * <code>builder</code>\r
1918      *\r
1919      * @param dataNodeContainer\r
1920      *            element which contains the list of used YANG groupings\r
1921      * @param builder\r
1922      *            builder to which are added implemented types according to\r
1923      *            <code>dataNodeContainer</code>\r
1924      * @return generated type builder with all implemented types\r
1925      */\r
1926     private def addImplementedInterfaceFromUses( DataNodeContainer dataNodeContainer,\r
1927             GeneratedTypeBuilder builder) {\r
1928         for (usesNode : dataNodeContainer.uses) {\r
1929             if (usesNode.groupingPath !== null) {\r
1930                 val genType = allGroupings.get(usesNode.groupingPath);\r
1931                 if (genType === null) {\r
1932                     throw new IllegalStateException("Grouping " + usesNode.groupingPath + "is not resolved for "\r
1933                             + builder.name);\r
1934                 }\r
1935                 builder.addImplementsType(genType);\r
1936             }\r
1937         }\r
1938         return builder;\r
1939     }\r
1940 }