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

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