binding2/mdsal-binding2-generator-impl/src/main/java/org/opendaylight/mdsal/binding/javav2/generator/impl/GenHelperUtil.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.mdsal.binding.javav2.generator.impl;
  10
  11 import static com.google.common.base.Preconditions.checkArgument;
  12 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.addTOToTypeBuilder;
  13 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.annotateDeprecatedIfNecessary;
  14 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.augGenTypeName;
  15 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.constructGetter;
  16 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createDescription;
  17 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.createReturnTypeForUnion;
  18 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.getAugmentIdentifier;
  19 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.isInnerType;
  20 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.qNameConstant;
  21 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveInnerEnumFromTypeDefinition;
  22 import static org.opendaylight.mdsal.binding.javav2.generator.impl.AuxiliaryGenUtils.resolveListKeyTOBuilder;
  23 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.computeDefaultSUID;
  24 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.encodeAngleBrackets;
  25 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil.packageNameForGeneratedType;
  26 import static org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes.NOTIFICATION;
  27 import static org.opendaylight.mdsal.binding.javav2.generator.util.Types.parameterizedTypeFor;
  28 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
  29 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
  30
  31 import com.google.common.annotations.Beta;
  32 import com.google.common.base.Preconditions;
  33 import com.google.common.collect.Iterables;
  34 import java.util.Collection;
  35 import java.util.HashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Set;
  39 import java.util.stream.Collectors;
  40 import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
  41 import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
  42 import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes;
  43 import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
  44 import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
  45 import org.opendaylight.mdsal.binding.javav2.generator.util.ReferencedTypeImpl;
  46 import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
  47 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
  48 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
  49 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
  50 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.GroupingDefinitionDependencySort;
  51 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
  52 import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier;
  53 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject;
  54 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
  55 import org.opendaylight.mdsal.binding.javav2.model.api.ParameterizedType;
  56 import org.opendaylight.mdsal.binding.javav2.model.api.Restrictions;
  57 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  58 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
  59 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder;
  60 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
  61 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
  62 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
  63 import org.opendaylight.mdsal.binding.javav2.spec.base.BaseIdentity;
  64 import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
  65 import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
  66 import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable;
  67 import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
  68 import org.opendaylight.yangtools.yang.common.QName;
  69 import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
  70 import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
  71 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
  72 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  73 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  74 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
  75 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  76 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  77 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  78 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
  79 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  80 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
  81 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  82 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  83 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  84 import org.opendaylight.yangtools.yang.model.api.Module;
  85 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  86 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  87 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  88 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  89 import org.opendaylight.yangtools.yang.model.api.Status;
  90 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  91 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  92 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  93 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  94 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  95 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
  96 import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
  97
  98 /**
  99  * Helper util class used for generation of types in Binding spec v2.
 100  */
 101 @Beta
 102 final class GenHelperUtil {
 103
 104     private GenHelperUtil() {
 105         throw new UnsupportedOperationException("Util class");
 106     }
 107
 108     /**
 109      * Create GeneratedTypeBuilder object from module argument.
 110      *
 111      * @param module
 112      *            Module object from which builder will be created
 113      * @param genCtx generated context
 114      * @param verboseClassComments verbosity switch
 115      *
 116      * @return <code>GeneratedTypeBuilder</code> which is internal
 117      *         representation of the module
 118      * @throws IllegalArgumentException
 119      *             if module is null
 120      */
 121     static GeneratedTypeBuilder moduleToDataType(final Module module, final Map<Module, ModuleContext> genCtx, final boolean verboseClassComments) {
 122         Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
 123
 124         final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments);
 125         addImplementedInterfaceFromUses(module, moduleDataTypeBuilder, genCtx);
 126         moduleDataTypeBuilder.addImplementsType(BindingTypes.TREE_ROOT);
 127         moduleDataTypeBuilder.addComment(module.getDescription());
 128         moduleDataTypeBuilder.setDescription(createDescription(module, verboseClassComments));
 129         moduleDataTypeBuilder.setReference(module.getReference());
 130         return moduleDataTypeBuilder;
 131     }
 132
 133     /**
 134      * Generates type builder for <code>module</code>.
 135      *
 136      * @param module
 137      *            Module which is source of package name for generated type
 138      *            builder
 139      * @param postfix
 140      *            string which is added to the module class name representation
 141      *            as suffix
 142      * @param verboseClassComments verbosity switch
 143      * @return instance of GeneratedTypeBuilder which represents
 144      *         <code>module</code>.
 145      * @throws IllegalArgumentException
 146      *             if <code>module</code> is null
 147      */
 148     static GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix, final boolean
 149             verboseClassComments) {
 150         Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
 151         final String packageName = BindingMapping.getRootPackageName(module);
 152         // underscore used as separator for distinction of module name parts
 153         final String moduleName = new StringBuilder(module.getName()).append('_').append(postfix).toString();
 154
 155         final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName);
 156         moduleBuilder.setDescription(createDescription(module, verboseClassComments));
 157         moduleBuilder.setReference(module.getReference());
 158         moduleBuilder.setModuleName(moduleName);
 159         return moduleBuilder;
 160     }
 161
 162     /**
 163      * Adds the implemented types to type builder.
 164      *
 165      * The method passes through the list of <i>uses</i> in
 166      * {@code dataNodeContainer}. For every <i>use</i> is obtained corresponding
 167      * generated type from all groupings
 168      * allGroupings} which is added as <i>implements type</i> to
 169      * <code>builder</code>
 170      *
 171      * @param dataNodeContainer
 172      *            element which contains the list of used YANG groupings
 173      * @param builder
 174      *            builder to which are added implemented types according to
 175      *            <code>dataNodeContainer</code>
 176      * @param genCtx generated context
 177      * @return generated type builder with all implemented types
 178      */
 179     static GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
 180                           final GeneratedTypeBuilder builder, final Map<Module, ModuleContext> genCtx) {
 181         for (final UsesNode usesNode : dataNodeContainer.getUses()) {
 182             final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath(), genCtx).toInstance();
 183             if (genType == null) {
 184                 throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
 185                     + builder.getName());
 186             }
 187             builder.addImplementsType(genType);
 188         }
 189         return builder;
 190     }
 191
 192      static GeneratedTypeBuilder findGroupingByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
 193         for (final ModuleContext ctx : genCtx.values()) {
 194             final GeneratedTypeBuilder result = ctx.getGrouping(path);
 195             if (result != null) {
 196                 return result;
 197             }
 198         }
 199         return null;
 200      }
 201
 202     static GeneratedTOBuilder findIdentityByQname(final QName qname, final Map<Module, ModuleContext> genCtx) {
 203         for (final ModuleContext ctx : genCtx.values()) {
 204             final GeneratedTOBuilder result = ctx.getIdentities().get(qname);
 205             if (result != null) {
 206                 return result;
 207             }
 208         }
 209         return null;
 210     }
 211
 212     /**
 213      * Adds the methods to <code>typeBuilder</code> which represent subnodes of
 214      * node for which <code>typeBuilder</code> was created.
 215      *
 216      * The subnodes aren't mapped to the methods if they are part of grouping or
 217      * augment (in this case are already part of them).
 218      *
 219      * @param module
 220      *            current module
 221      * @param basePackageName
 222      *            string contains the module package name
 223      * @param parent
 224      *            generated type builder which represents any node. The subnodes
 225      *            of this node are added to the <code>typeBuilder</code> as
 226      *            methods. The subnode can be of type leaf, leaf-list, list,
 227      *            container, choice.
 228      * @param childOf
 229      *            parent type
 230      * @param schemaNodes
 231      *            set of data schema nodes which are the children of the node
 232      *            for which <code>typeBuilder</code> was created
 233      * @return generated type builder which is the same builder as input
 234      *         parameter. The getter methods (representing child nodes) could be
 235      *         added to it.
 236      */
 237     static GeneratedTypeBuilder resolveDataSchemaNodes(final Module module, final String basePackageName,
 238                           final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf,
 239                           final Iterable<DataSchemaNode> schemaNodes, final Map<Module, ModuleContext> genCtx,
 240                           final SchemaContext schemaContext, final boolean verboseClassComments,
 241                           final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
 242                           final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
 243
 244         if (schemaNodes != null && parent != null) {
 245             for (final DataSchemaNode schemaNode : schemaNodes) {
 246                 if (!schemaNode.isAugmenting()) {
 247                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module, genCtx,
 248                             schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
 249                 }
 250             }
 251         }
 252         return parent;
 253     }
 254
 255     static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
 256             schemaNode, final Module module, final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext,
 257             final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
 258             final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
 259         return addDefaultInterfaceDefinition(basePackageName, schemaNode, null, module, genCtx, schemaContext,
 260                 verboseClassComments, genTypeBuilders, typeProvider , namespaceType);
 261     }
 262
 263     static Map<Module, ModuleContext> processUsesAugments(final SchemaContext schemaContext, final
 264                         DataNodeContainer node, final Module module, Map<Module, ModuleContext> genCtx,
 265                         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
 266                         final boolean verboseClassComments, final TypeProvider typeProvider,
 267                         final BindingNamespaceType namespaceType) {
 268         final String basePackageName = BindingMapping.getRootPackageName(module);
 269         for (final UsesNode usesNode : node.getUses()) {
 270             Map<SchemaPath, List<AugmentationSchema>> augmentationsGrouped =
 271                     usesNode.getAugmentations().stream().collect(Collectors.groupingBy(AugmentationSchema::getTargetPath));
 272             for (Map.Entry<SchemaPath, List<AugmentationSchema>> schemaPathAugmentListEntry : augmentationsGrouped.entrySet()) {
 273                 genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName,
 274                         schemaPathAugmentListEntry.getValue(), module,
 275                         usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider, namespaceType);
 276                 for (AugmentationSchema augSchema : schemaPathAugmentListEntry.getValue()) {
 277                     genCtx = processUsesAugments(schemaContext, augSchema, module, genCtx, genTypeBuilders,
 278                             verboseClassComments, typeProvider, namespaceType);
 279                 }
 280             }
 281         }
 282         return genCtx;
 283     }
 284
 285
 286     static void addUsesImplements(final DataNodeContainer superNode, final Module superModule,
 287             final DataNodeContainer node, final Module module,
 288             final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType ) {
 289         for (SchemaNode superChildNode : superNode.getChildNodes()) {
 290             if (superChildNode instanceof DataNodeContainer) {
 291                 final QName childQName = QName.create(((SchemaNode)node).getQName(), superChildNode.getQName().getLocalName());
 292                 DataSchemaNode childNode = node.getDataChildByName(childQName);
 293                 Preconditions.checkNotNull(childNode, ((SchemaNode) node).getPath() + "->" + childQName.toString());
 294
 295                 final GeneratedTypeBuilder type = genCtx.get(module).getChildNode(childNode.getPath());
 296                 final GeneratedTypeBuilder superType = genCtx.get(superModule).getChildNode(superChildNode.getPath());
 297
 298                 //TODO:delete this after supporting uses augment
 299                 if (type == null || superType == null) {
 300                     return;
 301                 }
 302                 Preconditions.checkNotNull(type, module.toString() + "->" + childNode.getPath().toString());
 303                 Preconditions.checkNotNull(superType, superModule.toString() + "->" + superChildNode.getPath().toString());
 304                 type.addImplementsType(superType);
 305                 addUsesImplements((DataNodeContainer)superChildNode, superModule, (DataNodeContainer)childNode, module, schemaContext, genCtx, namespaceType);
 306             }
 307         }
 308     }
 309
 310     static Map<Module, ModuleContext> processUsesImplements(final DataNodeContainer node, final Module module,
 311             final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx, final BindingNamespaceType namespaceType) {
 312
 313         for (final UsesNode usesNode : node.getUses()) {
 314             final SchemaNode groupingNode =  SchemaContextUtil.findDataSchemaNode(schemaContext, usesNode.getGroupingPath());
 315             Preconditions.checkNotNull(groupingNode, module.toString() + "->"
 316                     + usesNode.getGroupingPath().toString());
 317             Preconditions.checkState(groupingNode instanceof GroupingDefinition,
 318                     module.toString() + "->" + usesNode.getGroupingPath().toString());
 319             final Module superModule = SchemaContextUtil.findParentModule(schemaContext, groupingNode);
 320             GroupingDefinition grouping = (GroupingDefinition)groupingNode;
 321             addUsesImplements(grouping, superModule, node, module, schemaContext, genCtx, namespaceType);
 322         }
 323         return genCtx;
 324     }
 325
 326     static GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
 327         for (final ModuleContext ctx : genCtx.values()) {
 328             final GeneratedTypeBuilder result = ctx.getChildNode(path);
 329             if (result != null) {
 330                 return result;
 331             }
 332         }
 333         return null;
 334     }
 335
 336     static GeneratedTypeBuilder findCaseByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
 337         for (final ModuleContext ctx : genCtx.values()) {
 338             final GeneratedTypeBuilder result = ctx.getCase(path);
 339             if (result != null) {
 340                 return result;
 341             }
 342         }
 343         return null;
 344     }
 345
 346     static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
 347             final Type targetTypeRef, final List<AugmentationSchema> schemaPathAugmentListEntry,
 348             final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx,
 349             final SchemaContext schemaContext, final boolean verboseClassComments, final TypeProvider typeProvider,
 350             final BindingNamespaceType namespaceType) {
 351
 352         //pick augmentation grouped by augmentation target, there is always at least one
 353         final AugmentationSchema augSchema = schemaPathAugmentListEntry.get(0);
 354
 355         Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.computeIfAbsent(
 356                 augmentPackageName, k -> new HashMap<>());
 357
 358         //this requires valid semantics in YANG model
 359         String augIdentifier = null;
 360         for (AugmentationSchema aug : schemaPathAugmentListEntry) {
 361             augIdentifier = getAugmentIdentifier(aug.getUnknownSchemaNodes());
 362             break;
 363         }
 364
 365         boolean isTypeNormalized = false;
 366         if (augIdentifier == null) {
 367             augIdentifier = augGenTypeName(augmentBuilders, targetTypeRef.getName());
 368             isTypeNormalized = true;
 369         }
 370
 371         GeneratedTypeBuilderImpl augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier,
 372                 false, isTypeNormalized);
 373
 374         augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE);
 375         augTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, augTypeBuilder));
 376         augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
 377         augTypeBuilder.setBasePackageName(BindingMapping.getRootPackageName(module));
 378         augTypeBuilder.setWithBuilder(true);
 379         annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
 380
 381         //produces getters for augTypeBuilder eventually
 382         for (AugmentationSchema aug : schemaPathAugmentListEntry) {
 383             //apply all uses
 384             addImplementedInterfaceFromUses(aug, augTypeBuilder, genCtx);
 385             augSchemaNodeToMethods(module, BindingMapping.getRootPackageName(module), augTypeBuilder, augTypeBuilder, aug.getChildNodes(),
 386                genCtx, schemaContext, verboseClassComments, typeProvider, genTypeBuilders, namespaceType);
 387         }
 388
 389         augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder);
 390
 391         if(!augSchema.getChildNodes().isEmpty()) {
 392             genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema);
 393             genCtx.get(module).addTargetToAugmentation(augTypeBuilder, augSchema.getTargetPath());
 394         }
 395         genCtx.get(module).addAugmentType(augTypeBuilder);
 396         return genCtx;
 397     }
 398
 399     /**
 400      * Adds the methods to <code>typeBuilder</code> what represents subnodes of
 401      * node for which <code>typeBuilder</code> was created.
 402      *
 403      * @param module
 404      *            current module
 405      * @param basePackageName
 406      *            string contains the module package name
 407      * @param typeBuilder
 408      *            generated type builder which represents any node. The subnodes
 409      *            of this node are added to the <code>typeBuilder</code> as
 410      *            methods. The subnode can be of type leaf, leaf-list, list,
 411      *            container, choice.
 412      * @param childOf
 413      *            parent type
 414      * @param schemaNodes
 415      *            set of data schema nodes which are the children of the node
 416      *            for which <code>typeBuilder</code> was created
 417      * @return generated type builder which is the same object as the input
 418      *         parameter <code>typeBuilder</code>. The getter method could be
 419      *         added to it.
 420      */
 421     private static GeneratedTypeBuilder augSchemaNodeToMethods(final Module module, final String basePackageName,
 422             final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Iterable<DataSchemaNode> schemaNodes,
 423             final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
 424             verboseClassComments, final TypeProvider typeProvider, final Map<String, Map<String,
 425             GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
 426         if (schemaNodes != null && typeBuilder != null) {
 427             for (final DataSchemaNode schemaNode : schemaNodes) {
 428                 if (!schemaNode.isAugmenting()) {
 429                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder, childOf, module, genCtx,
 430                             schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
 431                 }
 432             }
 433         }
 434         return typeBuilder;
 435     }
 436
 437     /**
 438      * Instantiates generated type builder with <code>packageName</code> and
 439      * <code>schemaNode</code>.
 440      *
 441      * The new builder always implements
 442      * {@link TreeNode TreeNode}.<br>
 443      * If <code>schemaNode</code> is instance of GroupingDefinition it also
 444      * implements {@link Augmentable
 445      * Augmentable}.<br>
 446      * If <code>schemaNode</code> is instance of
 447      * {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer
 448      * DataNodeContainer} it can also implement nodes which are specified in
 449      * <i>uses</i>.
 450      *
 451      * @param basePackageName
 452      *            string contains the module package name
 453      * @param schemaNode
 454      *            schema node for which is created generated type builder
 455      * @param parent
 456      *            parent type (can be null)
 457      * @param schemaContext schema context
 458      * @return generated type builder <code>schemaNode</code>
 459      */
 460     private static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String basePackageName, final SchemaNode
 461             schemaNode, final Type parent, final Module module, final Map<Module, ModuleContext> genCtx,
 462             final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String,
 463             GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
 464
 465         String suffix = "";
 466         if (schemaNode instanceof GroupingDefinition) {
 467             suffix = "grouping";
 468         } else if (namespaceType.equals(BindingNamespaceType.Grouping)) {
 469             suffix = "data";
 470         }
 471
 472         GeneratedTypeBuilder it = addRawInterfaceDefinition(basePackageName, schemaNode, schemaContext, "", suffix,
 473                 verboseClassComments, genTypeBuilders, namespaceType);
 474         if (namespaceType.equals(BindingNamespaceType.Data)) {
 475             if (parent == null) {
 476                 it.addImplementsType(BindingTypes.TREE_NODE);
 477             } else {
 478                 if (parent instanceof ListSchemaNode) {
 479                     it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
 480                             (BindingTypes.IDENTIFIABLE_ITEM, parent)));
 481                 } else {
 482                     it.addImplementsType(parameterizedTypeFor(BindingTypes.TREE_CHILD_NODE, parent, parameterizedTypeFor
 483                             (BindingTypes.ITEM, parent)));
 484                     it.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, it));
 485                 }
 486             }
 487
 488             if (!(schemaNode instanceof GroupingDefinition)) {
 489                 it.addImplementsType(BindingTypes.augmentable(it));
 490             }
 491         } else {
 492             it.addImplementsType(BindingTypes.TREE_NODE);
 493         }
 494
 495         if (schemaNode instanceof DataNodeContainer) {
 496             groupingsToGenTypes(module, ((DataNodeContainer) schemaNode).getGroupings(), genCtx, schemaContext,
 497                     verboseClassComments, genTypeBuilders, typeProvider);
 498             it = addImplementedInterfaceFromUses((DataNodeContainer) schemaNode, it, genCtx);
 499         }
 500
 501         return it;
 502     }
 503
 504     static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, String
 505             parentName, final String basePackageName, final NotificationDefinition notification, final Module module,
 506             final SchemaContext schemaContext, final boolean verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>>
 507             genTypeBuilders, TypeProvider typeProvider, Map<Module, ModuleContext> genCtx) {
 508
 509         processUsesAugments(schemaContext, notification, module, genCtx, genTypeBuilders,
 510                 verboseClassComments, typeProvider, BindingNamespaceType.Data);
 511
 512         final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition
 513                 (basePackageName, notification, null, module, genCtx, schemaContext,
 514                         verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
 515         annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
 516         notificationInterface.addImplementsType(NOTIFICATION);
 517         genCtx.get(module).addChildNodeType(notification, notificationInterface);
 518
 519         // Notification object
 520         resolveDataSchemaNodes(module, basePackageName, notificationInterface,
 521                 notificationInterface, notification.getChildNodes(), genCtx, schemaContext,
 522                 verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Data);
 523
 524         //in case of tied notification, incorporate parent's localName
 525         final StringBuilder sb = new StringBuilder("on_");
 526         if (parentName != null) {
 527             sb.append(parentName).append('_');
 528         }
 529         sb.append(notificationInterface.getName());
 530
 531         listenerInterface.addMethod(JavaIdentifierNormalizer.normalizeSpecificIdentifier(sb.toString(), JavaIdentifier.METHOD))
 532                 .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
 533                 .setComment(encodeAngleBrackets(notification.getDescription())).setReturnType(Types.VOID);
 534         return listenerInterface;
 535     }
 536
 537     /**
 538      * Returns reference to generated type builder for specified
 539      * <code>schemaNode</code> with <code>packageName</code>.
 540      *
 541      * Firstly the generated type builder is searched in
 542      * {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't
 543      * found it is created and added to <code>genTypeBuilders</code>.
 544      *
 545      * @param basePackageName
 546      *            string contains the module package name
 547      * @param schemaNode
 548      *            schema node which provide data about the schema node name
 549      * @param schemaContext schema context
 550      * @param prefix
 551      *            return type name prefix
 552      * @return generated type builder for <code>schemaNode</code>
 553      * @throws IllegalArgumentException
 554      *             <ul>
 555      *             <li>if <code>schemaNode</code> is null</li>
 556      *             <li>if <code>packageName</code> is null</li>
 557      *             <li>if QName of schema node is null</li>
 558      *             <li>if schemaNode name is null</li>
 559      *             </ul>
 560      *
 561      */
 562     static GeneratedTypeBuilder addRawInterfaceDefinition(final String basePackageName, final SchemaNode schemaNode,
 563             final SchemaContext schemaContext, final String prefix, final String suffix,
 564             final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
 565             final BindingNamespaceType namespaceType) {
 566
 567         Preconditions.checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
 568         Preconditions.checkArgument(basePackageName != null, "Base package Name for Generated Type cannot be NULL.");
 569         String schemaNodeName = schemaNode.getQName().getLocalName();
 570         Preconditions.checkArgument(schemaNodeName != null, "Local Name of QName for Data Schema Node cannot be NULL.");
 571
 572         if (prefix != null && !prefix.isEmpty()) {
 573             // underscore used as separator for distinction of class name parts
 574             schemaNodeName = new StringBuilder(prefix).append('_').append(schemaNodeName).toString();
 575         }
 576
 577         if (suffix != null && !suffix.isEmpty()) {
 578             // underscore used as separator for distinction of class name parts
 579             schemaNodeName = new StringBuilder(schemaNodeName).append('_').append(suffix).toString();
 580         }
 581
 582         final String packageName = packageNameForGeneratedType(basePackageName, schemaNode.getPath(), namespaceType);
 583         final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, schemaNodeName);
 584         final Module module = SchemaContextUtil.findParentModule(schemaContext, schemaNode);
 585         qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
 586         newType.addComment(schemaNode.getDescription());
 587         newType.setDescription(createDescription(schemaNode, newType.getFullyQualifiedName(), schemaContext,
 588                 verboseClassComments, namespaceType));
 589         newType.setReference(schemaNode.getReference());
 590         newType.setSchemaPath((List<QName>) schemaNode.getPath().getPathFromRoot());
 591         newType.setModuleName(module.getName());
 592         newType.setBasePackageName(BindingMapping.getRootPackageName(module));
 593         newType.setWithBuilder(AuxiliaryGenUtils.hasBuilderClass(schemaNode, namespaceType));
 594
 595         if (!genTypeBuilders.containsKey(packageName)) {
 596             final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
 597             builders.put(newType.getName(), newType);
 598             genTypeBuilders.put(packageName, builders);
 599         } else {
 600             final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
 601             if (!builders.containsKey(newType.getName())) {
 602                 builders.put(newType.getName(), newType);
 603             }
 604         }
 605         return newType;
 606
 607     }
 608
 609     private static void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode node,
 610         final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Module module,
 611         final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean verboseClassComments,
 612         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
 613         final BindingNamespaceType namespaceType) {
 614
 615         if (node != null && typeBuilder != null) {
 616             if (node instanceof ContainerSchemaNode) {
 617                 containerToGenType(module, basePackageName, typeBuilder, childOf, (ContainerSchemaNode) node,
 618                         schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
 619             } else if (node instanceof LeafListSchemaNode) {
 620                 resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) node, module,
 621                             typeProvider, genCtx);
 622             } else if (node instanceof LeafSchemaNode) {
 623                 resolveLeafSchemaNodeAsMethod("", schemaContext, typeBuilder, genCtx, (LeafSchemaNode) node, module,
 624                         typeProvider);
 625             } else if (node instanceof ListSchemaNode) {
 626                 listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
 627                         verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
 628             } else if (node instanceof ChoiceSchemaNode) {
 629                 choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, childOf,
 630                         (ChoiceSchemaNode) node, genTypeBuilders, genCtx, typeProvider, namespaceType);
 631             } else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
 632                 resolveAnyNodeAsMethod(schemaContext, typeBuilder, genCtx, node, module, typeProvider);
 633             }
 634         }
 635     }
 636
 637     /**
 638      * Converts <code>choiceNode</code> to the list of generated types for
 639      * choice and its cases.
 640      *
 641      * The package names for choice and for its cases are created as
 642      * concatenation of the module package (<code>basePackageName</code>) and
 643      * names of all parents node.
 644      *
 645      * @param module
 646      *            current module
 647      * @param basePackageName
 648      *            string with the module package name
 649      * @param parent
 650      *            parent type
 651      * @param choiceNode
 652      *            choice node which is mapped to generated type. Also child
 653      *            nodes - cases are mapped to generated types.
 654      * @throws IllegalArgumentException
 655      *             <ul>
 656      *             <li>if <code>basePackageName</code> is null</li>
 657      *             <li>if <code>choiceNode</code> is null</li>
 658      *             </ul>
 659      */
 660     private static void choiceToGenType(final Module module, final SchemaContext schemaContext, final boolean
 661             verboseClasssComments, final String basePackageName, final GeneratedTypeBuilder parent, final
 662             ChoiceSchemaNode choiceNode, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
 663             final Map<Module, ModuleContext> genCtx, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
 664         checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
 665         checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
 666
 667         if (!choiceNode.isAddedByUses()) {
 668             final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(basePackageName, choiceNode,
 669                     schemaContext, "", "", verboseClasssComments, genTypeBuilders, namespaceType);
 670             constructGetter(parent, choiceNode.getQName().getLocalName(),
 671                     choiceNode.getDescription(), choiceTypeBuilder, choiceNode.getStatus());
 672             choiceTypeBuilder.addImplementsType(parameterizedTypeFor(BindingTypes.INSTANTIABLE, choiceTypeBuilder));
 673             annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
 674             genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
 675             generateTypesFromChoiceCases(module, schemaContext, genCtx, basePackageName, choiceTypeBuilder.toInstance(),
 676                 choiceNode, verboseClasssComments, typeProvider, genTypeBuilders, namespaceType);
 677         }
 678     }
 679
 680     private static void containerToGenType(final Module module, final String basePackageName,
 681         final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ContainerSchemaNode node,
 682         final SchemaContext schemaContext, final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
 683         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
 684         final BindingNamespaceType namespaceType) {
 685
 686         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
 687                 schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
 688         if (genType != null) {
 689             StringBuilder getterName = new StringBuilder(node.getQName().getLocalName());
 690             if (!namespaceType.equals(BindingNamespaceType.Data)) {
 691                 getterName.append('_').append(BindingNamespaceType.Data);
 692             }
 693             final MethodSignatureBuilder getter = constructGetter(parent, getterName.toString(), node.getDescription(), genType, node.getStatus());
 694             if (!namespaceType.equals(BindingNamespaceType.Data)) {
 695                 getter.setAccessModifier(AccessModifier.DEFAULT);
 696             }
 697             resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes(), genCtx,
 698                     schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
 699             processUsesImplements(node, module, schemaContext, genCtx, namespaceType);
 700         }
 701     }
 702
 703     private static void listToGenType(final Module module, final String basePackageName, final GeneratedTypeBuilder
 704             parent, final GeneratedTypeBuilder childOf, final ListSchemaNode node, final SchemaContext schemaContext,
 705             final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
 706             final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider,
 707             final BindingNamespaceType namespaceType) {
 708
 709         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
 710                 schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
 711         if (genType != null) {
 712             final String nodeName = node.getQName().getLocalName();
 713             constructGetter(parent, nodeName, node.getDescription(), Types.listTypeFor(genType), node.getStatus());
 714             final List<QName> listKeys = node.getKeyDefinition();
 715             final String packageName = new StringBuilder(packageNameForGeneratedType(basePackageName, node.getPath(),
 716                     BindingNamespaceType.Key)).append('.').append(nodeName).toString();
 717
 718             final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node);
 719
 720             for (final DataSchemaNode schemaNode : node.getChildNodes()) {
 721                 if (!schemaNode.isAugmenting()) {
 722                     addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
 723                             module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments, namespaceType);
 724                 }
 725             }
 726
 727             // serialVersionUID
 728             if (genTOBuilder != null) {
 729                 final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
 730                 prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder)));
 731                 genTOBuilder.setSUID(prop);
 732             }
 733
 734             typeBuildersToGenTypes(module, genType, genTOBuilder, genCtx);
 735         }
 736     }
 737
 738     private static void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder,
 739             final GeneratedTOBuilder genTOBuilder, final Map<Module, ModuleContext> genCtx) {
 740         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
 741         if (genTOBuilder != null) {
 742             final GeneratedTransferObject genTO = genTOBuilder.toInstance();
 743             constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO, Status.CURRENT);
 744             genCtx.get(module).addGeneratedTOBuilder(genTOBuilder);
 745         }
 746     }
 747
 748     /**
 749      * Converts <code>leaf</code> to the getter method which is added to
 750      * <code>typeBuilder</code>.
 751      *
 752      * @param typeBuilder
 753      *            generated type builder to which is added getter method as
 754      *            <code>leaf</code> mapping
 755      * @param leaf
 756      *            leaf schema node which is mapped as getter method which is
 757      *            added to <code>typeBuilder</code>
 758      * @param module
 759      *            Module in which type was defined
 760      * @return boolean value
 761      *         <ul>
 762      *         <li>false - if <code>leaf</code> or <code>typeBuilder</code> are
 763      *         null</li>
 764      *         <li>true - in other cases</li>
 765      *         </ul>
 766      */
 767     private static Type resolveLeafSchemaNodeAsMethod(final String nodeName, final SchemaContext schemaContext,
 768             final GeneratedTypeBuilder typeBuilder, final Map<Module, ModuleContext> genCtx, final LeafSchemaNode leaf,
 769             final Module module, final TypeProvider typeProvider) {
 770         if (leaf == null || typeBuilder == null) {
 771             return null;
 772         }
 773
 774         final String leafName = leaf.getQName().getLocalName();
 775         if (leafName == null) {
 776             return null;
 777         }
 778
 779         final Module parentModule = findParentModule(schemaContext, leaf);
 780         Type returnType = null;
 781
 782         final TypeDefinition<?> typeDef = leaf.getType();
 783         if (isInnerType(leaf, typeDef)) {
 784             if (typeDef instanceof EnumTypeDefinition) {
 785                 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
 786                 final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
 787                 final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(),
 788                         genCtx, typeBuilder, module);
 789                 if (enumBuilder != null) {
 790                     returnType = enumBuilder.toInstance(typeBuilder);
 791                 }
 792                 ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
 793             } else if (typeDef instanceof UnionTypeDefinition) {
 794                 final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
 795                         typeProvider, schemaContext);
 796                 if (genTOBuilder != null) {
 797                     //TODO: https://bugs.opendaylight.org/show_bug.cgi?id=2289
 798                     returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider);
 799                 }
 800             } else if (typeDef instanceof BitsTypeDefinition) {
 801                 final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
 802                         typeProvider, schemaContext);
 803                 if (genTOBuilder != null) {
 804                     returnType = genTOBuilder.toInstance();
 805                 }
 806             } else {
 807                 // It is constrained version of already declared type (inner declared type exists,
 808                 // onlyfor special cases (Enum, Union, Bits), which were already checked.
 809                 // In order to get proper class we need to look up closest derived type
 810                 // and apply restrictions from leaf type
 811                 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
 812                 returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf,
 813                         restrictions);
 814             }
 815         } else {
 816             final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
 817             returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions);
 818         }
 819
 820         if (returnType == null) {
 821             return null;
 822         }
 823
 824         if (typeDef instanceof EnumTypeDefinition) {
 825             ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
 826         }
 827
 828         String leafDesc = leaf.getDescription();
 829         if (leafDesc == null) {
 830             leafDesc = "";
 831         }
 832
 833         final String leafGetterName;
 834         if (!"".equals(nodeName)) {
 835             StringBuilder sb = new StringBuilder(nodeName)
 836                 .append('_')
 837                 .append(leafName);
 838             leafGetterName = sb.toString();
 839         } else {
 840             leafGetterName = leafName;
 841         }
 842
 843         constructGetter(typeBuilder, leafGetterName, leafDesc, returnType, leaf.getStatus());
 844         return returnType;
 845     }
 846
 847     /**
 848      * Converts <code>node</code> leaf list schema node to getter method of
 849      * <code>typeBuilder</code>.
 850      *
 851      * @param typeBuilder
 852      *            generated type builder to which is <code>node</code> added as
 853      *            getter method
 854      * @param node
 855      *            leaf list schema node which is added to
 856      *            <code>typeBuilder</code> as getter method
 857      * @param module module
 858      * @param typeProvider type provider instance
 859      * @param genCtx actual generated context
 860      * @return boolean value
 861      *         <ul>
 862      *         <li>true - if <code>node</code>, <code>typeBuilder</code>,
 863      *         nodeName equal null or <code>node</code> is added by <i>uses</i></li>
 864      *         <li>false - other cases</li>
 865      *         </ul>
 866      */
 867     private static boolean resolveLeafListSchemaNode(final SchemaContext schemaContext, final GeneratedTypeBuilder
 868             typeBuilder, final LeafListSchemaNode node, final Module module, final TypeProvider typeProvider,
 869             final Map<Module, ModuleContext> genCtx) {
 870         if (node == null || typeBuilder == null || node.isAddedByUses()) {
 871             return false;
 872         }
 873
 874         final QName nodeName = node.getQName();
 875
 876         final TypeDefinition<?> typeDef = node.getType();
 877         final Module parentModule = findParentModule(schemaContext, node);
 878
 879         Type returnType = null;
 880         if (typeDef.getBaseType() == null) {
 881             if (typeDef instanceof EnumTypeDefinition) {
 882                 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node);
 883                 final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
 884                 final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName,
 885                         genCtx, typeBuilder, module);
 886                 returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
 887                 ((TypeProviderImpl) typeProvider).putReferencedType(node.getPath(), returnType);
 888             } else if (typeDef instanceof UnionTypeDefinition) {
 889                 final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
 890                         typeProvider, schemaContext);
 891                 if (genTOBuilder != null) {
 892                     returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider);
 893                 }
 894             } else if (typeDef instanceof BitsTypeDefinition) {
 895                 final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule,
 896                         typeProvider, schemaContext);
 897                 returnType = genTOBuilder.toInstance();
 898             } else {
 899                 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
 900                 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions);
 901             }
 902         } else {
 903             final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
 904             returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions);
 905         }
 906
 907         final ParameterizedType listType = Types.listTypeFor(returnType);
 908         constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription(), listType, node.getStatus());
 909         return true;
 910     }
 911
 912     /**
 913      * Converts <code>caseNodes</code> set to list of corresponding generated
 914      * types.
 915      *
 916      * For every <i>case</i> which isn't added through augment or <i>uses</i> is
 917      * created generated type builder. The package names for the builder is
 918      * created as concatenation of the module package (
 919      * <code>basePackageName</code>) and names of all parents nodes of the
 920      * concrete <i>case</i>. There is also relation "<i>implements type</i>"
 921      * between every case builder and <i>choice</i> type
 922      *
 923      * @param module
 924      *            current module
 925      * @param schemaContext
 926      *            current schema context
 927      * @param genCtx
 928      *            actual generated context
 929      * @param basePackageName
 930      *            string with the module package name
 931      * @param refChoiceType
 932      *            type which represents superior <i>case</i>
 933      * @param choiceNode
 934      *            choice case node which is mapped to generated type
 935      * @param verboseClassComments
 936      *            Javadoc verbosity switch
 937      * @throws IllegalArgumentException
 938      *             <ul>
 939      *             <li>if <code>basePackageName</code> equals null</li>
 940      *             <li>if <code>refChoiceType</code> equals null</li>
 941      *             <li>if <code>caseNodes</code> equals null</li>
 942      *             </ul>
 943      */
 944     private static void generateTypesFromChoiceCases(final Module module, final SchemaContext schemaContext,
 945             final Map<Module, ModuleContext> genCtx, final String basePackageName, final Type refChoiceType,
 946             final ChoiceSchemaNode choiceNode, final boolean verboseClassComments, final TypeProvider typeProvider,
 947             final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final BindingNamespaceType namespaceType) {
 948         checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
 949         checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
 950         checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
 951
 952         final Set<ChoiceCaseNode> caseNodes = choiceNode.getCases();
 953         if (caseNodes == null) {
 954             return;
 955         }
 956
 957         for (final ChoiceCaseNode caseNode : caseNodes) {
 958             if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
 959                 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(basePackageName, caseNode,
 960                     module, genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
 961                 caseTypeBuilder.addImplementsType(refChoiceType);
 962                 caseTypeBuilder.setParentTypeForBuilder(refChoiceType);
 963                 annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
 964                 genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
 965                 genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
 966                 final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
 967                 if (caseChildNodes != null) {
 968                     final SchemaPath choiceNodeParentPath = choiceNode.getPath().getParent();
 969
 970                     if (!Iterables.isEmpty(choiceNodeParentPath.getPathFromRoot())) {
 971                         SchemaNode parent = findDataSchemaNode(schemaContext, choiceNodeParentPath);
 972
 973                         if (parent instanceof AugmentationSchema) {
 974                             final AugmentationSchema augSchema = (AugmentationSchema) parent;
 975                             final SchemaPath targetPath = augSchema.getTargetPath();
 976                             SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
 977                             if (targetSchemaNode instanceof DataSchemaNode
 978                                     && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
 979                                 if (targetSchemaNode instanceof DerivableSchemaNode) {
 980                                     targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orNull();
 981                                 }
 982                                 if (targetSchemaNode == null) {
 983                                     throw new IllegalStateException(
 984                                             "Failed to find target node from grouping for augmentation " + augSchema
 985                                                     + " in module " + module.getName());
 986                                 }
 987                             }
 988                             parent = targetSchemaNode;
 989                         }
 990
 991                         Preconditions.checkState(parent != null, "Could not find Choice node parent %s",
 992                                 choiceNodeParentPath);
 993                         GeneratedTypeBuilder childOfType = findChildNodeByPath(parent.getPath(), genCtx);
 994                         if (childOfType == null) {
 995                             childOfType = findGroupingByPath(parent.getPath(), genCtx);
 996                         }
 997                         resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes,
 998                                 genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
 999                     } else {
1000                         resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, moduleToDataType(module,
1001                                 genCtx, verboseClassComments), caseChildNodes, genCtx, schemaContext,
1002                                 verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
1003                     }
1004                 }
1005             }
1006             processUsesAugments(schemaContext, caseNode, module, genCtx, genTypeBuilders, verboseClassComments,
1007                     typeProvider, namespaceType);
1008         }
1009     }
1010
1011     private static Type resolveAnyNodeAsMethod(final SchemaContext schemaContext, final GeneratedTypeBuilder
1012             typeBuilder, final Map<Module, ModuleContext> genCtx, final DataSchemaNode node, final Module module,
1013             final TypeProvider typeProvider) {
1014
1015         final String anyName = node.getQName().getLocalName();
1016         if (anyName == null) {
1017             return null;
1018         }
1019
1020         String anyDesc = node.getDescription();
1021         if (anyDesc == null) {
1022             anyDesc = "";
1023         }
1024
1025         Type returnType = Types.DOCUMENT;
1026
1027         constructGetter(typeBuilder, anyName, anyDesc, returnType, node.getStatus());
1028         return returnType;
1029     }
1030
1031     /**
1032      * Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method
1033      * or to <code>genTOBuilder</code> as property.
1034      *
1035      * @param nodeName
1036      *            string contains the name of list
1037      * @param basePackageName
1038      *            string contains the module package name
1039      * @param schemaNode
1040      *            data schema node which should be added as getter method to
1041      *            <code>typeBuilder</code> or as a property to
1042      *            <code>genTOBuilder</code> if is part of the list key
1043      * @param typeBuilder
1044      *            generated type builder for the list schema node
1045      * @param genTOBuilder
1046      *            generated TO builder for the list keys
1047      * @param listKeys
1048      *            list of string which contains QNames of the list keys
1049      * @param module
1050      *            current module
1051      * @param typeProvider
1052      *            provider that defines contract for generated types
1053      * @param schemaContext
1054      *            schema context
1055      * @param genCtx
1056      *            map of generated entities in context of YANG modules
1057      * @param genTypeBuilders
1058      *            map of generated type builders
1059      * @param verboseClassComments
1060      *            generate verbose comments
1061      * @throws IllegalArgumentException
1062      *             <ul>
1063      *             <li>if <code>schemaNode</code> equals null</li>
1064      *             <li>if <code>typeBuilder</code> equals null</li>
1065      *             </ul>
1066      */
1067     private static void addSchemaNodeToListBuilders(final String nodeName, final String basePackageName,
1068             final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
1069             final GeneratedTOBuilder genTOBuilder, final List<QName> listKeys, final Module module,
1070             final TypeProvider typeProvider, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
1071             final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments,
1072             final BindingNamespaceType namespaceType) {
1073         checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
1074         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
1075
1076         if (schemaNode instanceof LeafSchemaNode) {
1077             final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
1078             final QName leafQName = leaf.getQName();
1079
1080             final Type type = resolveLeafSchemaNodeAsMethod(nodeName, schemaContext, typeBuilder, genCtx, leaf, module,
1081                     typeProvider);
1082             if (listKeys.contains(leafQName)) {
1083                 if (type == null) {
1084                     resolveLeafSchemaNodeAsProperty(schemaContext, typeProvider, genCtx, genTOBuilder, leaf, true,
1085                         module);
1086                 } else {
1087                     AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, type, true);
1088                 }
1089             }
1090         } else if (!schemaNode.isAddedByUses()) {
1091             if (schemaNode instanceof LeafListSchemaNode) {
1092                 resolveLeafListSchemaNode(schemaContext, typeBuilder, (LeafListSchemaNode) schemaNode, module,
1093                         typeProvider, genCtx);
1094             } else if (schemaNode instanceof ContainerSchemaNode) {
1095                 containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
1096                         schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
1097             } else if (schemaNode instanceof ListSchemaNode) {
1098                 listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
1099                         schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider, namespaceType);
1100             } else if (schemaNode instanceof ChoiceSchemaNode) {
1101                 choiceToGenType(module, schemaContext, verboseClassComments, basePackageName, typeBuilder,
1102                         (ChoiceSchemaNode) schemaNode, genTypeBuilders, genCtx, typeProvider, namespaceType);
1103             }
1104         }
1105     }
1106
1107     private static boolean resolveLeafSchemaNodeAsProperty(final SchemaContext schemaContext, final TypeProvider
1108             typeProvider, final Map<Module, ModuleContext> genCtx, final GeneratedTOBuilder
1109             toBuilder, final LeafSchemaNode leaf, final boolean isReadOnly, final Module module) {
1110
1111         if (leaf != null && toBuilder != null) {
1112             Type returnType;
1113             final TypeDefinition<?> typeDef = leaf.getType();
1114             if (typeDef instanceof UnionTypeDefinition) {
1115                 // GeneratedType for this type definition should be already
1116                 // created
1117                 final QName qname = typeDef.getQName();
1118                 final Module unionModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
1119                         qname.getRevision());
1120                 final ModuleContext mc = genCtx.get(unionModule);
1121                 returnType = mc.getTypedefs().get(typeDef.getPath());
1122             } else if (typeDef instanceof EnumTypeDefinition && typeDef.getBaseType() == null) {
1123                 // Annonymous enumeration (already generated, since it is inherited via uses).
1124                 LeafSchemaNode originalLeaf = (LeafSchemaNode) SchemaNodeUtils.getRootOriginalIfPossible(leaf);
1125                 QName qname = originalLeaf.getQName();
1126                 final Module enumModule =  schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
1127                         qname.getRevision());
1128                 returnType = genCtx.get(enumModule).getInnerType(originalLeaf.getType().getPath());
1129             } else {
1130                 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
1131             }
1132             return AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(toBuilder, leaf, returnType, isReadOnly);
1133         }
1134         return false;
1135     }
1136
1137     private static TypeDefinition<?> getBaseOrDeclaredType(final TypeDefinition<?> typeDef) {
1138         final TypeDefinition<?> baseType = typeDef.getBaseType();
1139         return (baseType != null && baseType.getBaseType() != null) ? baseType : typeDef;
1140     }
1141
1142     @SuppressWarnings({ "rawtypes", "unchecked" })
1143     private static GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
1144         final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext,
1145         final boolean verboseClassComments, Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
1146         GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider, final BindingNamespaceType namespaceType) {
1147
1148         if (node.isAugmenting()) {
1149             return null;
1150         }
1151
1152         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, node, childOf, module,
1153                 genCtx, schemaContext, verboseClassComments, genTypeBuilders, typeProvider, namespaceType);
1154         genType.addComment(node.getDescription());
1155         annotateDeprecatedIfNecessary(node.getStatus(), genType);
1156         genType.setDescription(createDescription(node, genType.getFullyQualifiedName(), schemaContext,
1157                 verboseClassComments, namespaceType));
1158         genType.setModuleName(module.getName());
1159         genType.setReference(node.getReference());
1160         genType.setSchemaPath((List) node.getPath().getPathFromRoot());
1161         genType.setParentTypeForBuilder(childOf);
1162         if (node instanceof DataNodeContainer) {
1163             genCtx.get(module).addChildNodeType(node, genType);
1164             processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders,
1165                     verboseClassComments, typeProvider, namespaceType);
1166         }
1167         return genType;
1168     }
1169
1170     /**
1171      * Converts all <b>groupings</b> of the module to the list of
1172      * <code>Type</code> objects. Firstly are groupings sorted according mutual
1173      * dependencies. At least dependent (independent) groupings are in the list
1174      * saved at first positions. For every grouping the record is added to map
1175      * {@link ModuleContext#groupings allGroupings}
1176      *
1177      * @param module
1178      *            current module
1179      * @param groupings
1180      *            collection of groupings from which types will be generated
1181      * @param typeProvider
1182      *            provider that defines contract for generated types
1183      * @param schemaContext
1184      *            schema context
1185      * @param genCtx
1186      *            map of generated entities in context of YANG modules
1187      * @param genTypeBuilders
1188      *            map of generated type builders
1189      * @param verboseClassComments
1190      *            generate verbose comments
1191      *
1192      */
1193     static Map<Module, ModuleContext> groupingsToGenTypes(final Module module, final Collection<GroupingDefinition>
1194             groupings, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
1195             verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
1196         final String basePackageName = BindingMapping.getRootPackageName(module);
1197         final List<GroupingDefinition> groupingsSortedByDependencies = new GroupingDefinitionDependencySort()
1198                 .sort(groupings);
1199         for (final GroupingDefinition grouping : groupingsSortedByDependencies) {
1200             genCtx = groupingToGenType(basePackageName, grouping, module, genCtx, schemaContext,
1201                     verboseClassComments, genTypeBuilders, typeProvider);
1202         }
1203         return genCtx;
1204     }
1205
1206     /**
1207      * Converts individual grouping to GeneratedType. Firstly generated type
1208      * builder is created and every child node of grouping is resolved to the
1209      * method.
1210      *
1211      * @param basePackageName
1212      *            string contains the module package name
1213      * @param grouping
1214      *            GroupingDefinition which contains data about grouping
1215      * @param module
1216      *            current module
1217      * @param typeProvider
1218      *            provider that defines contract for generated types
1219      * @param schemaContext
1220      *            schema context
1221      * @param genCtx
1222      *            map of generated entities in context of YANG modules
1223      * @param genTypeBuilders
1224      *            map of generated type builders
1225      * @param verboseClassComments
1226      *            generate verbose comments
1227      *
1228      * @return GeneratedType which is generated from grouping (object of type
1229      *         <code>GroupingDefinition</code>)
1230      */
1231     private static Map<Module, ModuleContext> groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module
1232             module, Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean
1233             verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
1234         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(basePackageName, grouping, module, genCtx,
1235                 schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
1236         annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
1237         genCtx.get(module).addGroupingType(grouping, genType);
1238         resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes(), genCtx,
1239                 schemaContext, verboseClassComments, genTypeBuilders, typeProvider, BindingNamespaceType.Grouping);
1240         genCtx = processUsesAugments(schemaContext, grouping, module, genCtx, genTypeBuilders, verboseClassComments,
1241                 typeProvider, BindingNamespaceType.Grouping);
1242         genCtx = processUsesImplements(grouping, module, schemaContext, genCtx, BindingNamespaceType.Grouping);
1243         return genCtx;
1244     }
1245
1246     /**
1247      * //TODO: add information about multiple base identities in YANG 1.1
1248      * Converts the <b>identity</b> object to GeneratedType. Firstly it is
1249      * created transport object builder. If identity contains base identity then
1250      * reference to base identity is added to superior identity as its extend.
1251      * If identity doesn't contain base identity then only reference to abstract
1252      * class {@link org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode
1253      * BaseIdentity} is added
1254      *
1255      * @param module
1256      *            current module
1257      * @param basePackageName
1258      *            string contains the module package name
1259      * @param identity
1260      *            IdentitySchemaNode which contains data about identity
1261      * @param schemaContext
1262      *            SchemaContext which is used to get package and name
1263      *            information about base of identity
1264      * @param genCtx generated context
1265      * @return returns generated context
1266      */
1267     static Map<Module, ModuleContext> identityToGenType(final Module module, final String basePackageName,
1268             final IdentitySchemaNode identity, final SchemaContext schemaContext, Map<Module, ModuleContext> genCtx,
1269             boolean verboseClassComments) {
1270
1271         resolveIdentitySchemaNode(basePackageName, schemaContext, identity, module, verboseClassComments, genCtx);
1272         return genCtx;
1273     }
1274
1275     private static GeneratedTOBuilder resolveIdentitySchemaNode(final String basePackageName, final SchemaContext schemaContext,
1276             final IdentitySchemaNode identity, final Module module, final boolean verboseClassComments,
1277             final Map<Module, ModuleContext> genCtx) {
1278         Preconditions.checkNotNull(identity,"Identity can not be null!");
1279
1280         //check first if identity has been resolved as base identity of some other one
1281         GeneratedTOBuilder newType = findIdentityByQname(identity.getQName(), genCtx);
1282         if (newType == null) {
1283             final Module parentModule = SchemaContextUtil.findParentModule(schemaContext, identity);
1284             Preconditions.checkState(module.equals(parentModule),
1285                     "If the type is null ,it must be in the same module, otherwise it must has been"
1286                             + "resolved by an imported module.");
1287
1288             final String packageName = BindingGeneratorUtil.packageNameForGeneratedType(basePackageName, identity.getPath(),
1289                     BindingNamespaceType.Identity);
1290             newType = new GeneratedTOBuilderImpl(packageName, identity.getQName().getLocalName(), true, false);
1291
1292             final Set<IdentitySchemaNode> baseIdentities = identity.getBaseIdentities();
1293             if (baseIdentities.size() == 0) {
1294                 //no base - abstract
1295                 final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
1296                         BaseIdentity.class.getSimpleName());
1297                 newType.setExtendsType(gto.toInstance());
1298             } else {
1299                 //one base - inheritance
1300                 final IdentitySchemaNode baseIdentity = baseIdentities.iterator().next();
1301                 GeneratedTOBuilder baseType = resolveIdentitySchemaNode(basePackageName, schemaContext,
1302                     baseIdentity, module, verboseClassComments, genCtx);
1303                 newType.setExtendsType(baseType.toInstance());
1304             }
1305
1306             newType.setAbstract(true);
1307             newType.addComment(identity.getDescription());
1308             newType.setDescription(createDescription(identity, newType.getFullyQualifiedName(), schemaContext,
1309                     verboseClassComments, BindingNamespaceType.Identity));
1310             newType.setReference(identity.getReference());
1311             newType.setModuleName(module.getName());
1312             newType.setSchemaPath((List) identity.getPath().getPathFromRoot());
1313
1314             qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, identity.getQName());
1315
1316             genCtx.get(module).addIdentityType(identity.getQName(), newType);
1317         }
1318         return newType;
1319     }
1320 }