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