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

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