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.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
  28
  29 import com.google.common.annotations.Beta;
  30 import com.google.common.base.Preconditions;
  31 import java.util.HashMap;
  32 import java.util.List;
  33 import java.util.Map;
  34 import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
  35 import org.opendaylight.mdsal.binding.javav2.generator.util.BindingGeneratorUtil;
  36 import org.opendaylight.mdsal.binding.javav2.generator.util.BindingTypes;
  37 import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
  38 import org.opendaylight.mdsal.binding.javav2.generator.util.NonJavaCharsConverter;
  39 import org.opendaylight.mdsal.binding.javav2.generator.util.Types;
  40 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
  41 import org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
  42 import org.opendaylight.mdsal.binding.javav2.generator.yang.types.TypeProviderImpl;
  43 import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier;
  44 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedTransferObject;
  45 import org.opendaylight.mdsal.binding.javav2.model.api.GeneratedType;
  46 import org.opendaylight.mdsal.binding.javav2.model.api.Restrictions;
  47 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
  48 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
  49 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder;
  50 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
  51 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
  52 import org.opendaylight.mdsal.binding.javav2.spec.base.TreeNode;
  53 import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
  54 import org.opendaylight.mdsal.binding.javav2.spec.structural.Augmentable;
  55 import org.opendaylight.mdsal.binding.javav2.util.BindingMapping;
  56 import org.opendaylight.yangtools.yang.common.QName;
  57 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  58 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  59 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  60 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  61 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  62 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  63 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  64 import org.opendaylight.yangtools.yang.model.api.Module;
  65 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  66 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  67 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  68 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  69 import org.opendaylight.yangtools.yang.model.api.Status;
  70 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  71 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  72 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  73 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  74 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  75 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
  76
  77 /**
  78  * Helper util class used for generation of types in Binding spec v2.
  79  */
  80 @Beta
  81 final class GenHelperUtil {
  82
  83     private GenHelperUtil() {
  84         throw new UnsupportedOperationException("Util class");
  85     }
  86
  87     /**
  88      * Create GeneratedTypeBuilder object from module argument.
  89      *
  90      * @param module
  91      *            Module object from which builder will be created
  92      * @param genCtx
  93      * @param verboseClassComments
  94      *
  95      * @return <code>GeneratedTypeBuilder</code> which is internal
  96      *         representation of the module
  97      * @throws IllegalArgumentException
  98      *             if module is null
  99      */
 100     static GeneratedTypeBuilder moduleToDataType(final Module module, final Map<Module, ModuleContext> genCtx, final boolean verboseClassComments) {
 101         Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
 102
 103         final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data", verboseClassComments);
 104         addImplementedInterfaceFromUses(module, moduleDataTypeBuilder, genCtx);
 105         moduleDataTypeBuilder.addImplementsType(BindingTypes.TREE_ROOT);
 106         moduleDataTypeBuilder.addComment(module.getDescription());
 107         moduleDataTypeBuilder.setDescription(createDescription(module, verboseClassComments));
 108         moduleDataTypeBuilder.setReference(module.getReference());
 109         return moduleDataTypeBuilder;
 110     }
 111
 112     /**
 113      * Generates type builder for <code>module</code>.
 114      *
 115      * @param module
 116      *            Module which is source of package name for generated type
 117      *            builder
 118      * @param postfix
 119      *            string which is added to the module class name representation
 120      *            as suffix
 121      * @param verboseClassComments
 122      * @return instance of GeneratedTypeBuilder which represents
 123      *         <code>module</code>.
 124      * @throws IllegalArgumentException
 125      *             if <code>module</code> is null
 126      */
 127     static GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix, final boolean
 128             verboseClassComments) {
 129         Preconditions.checkArgument(module != null, "Module reference cannot be NULL.");
 130         final String packageName = BindingMapping.getRootPackageName(module);
 131         // underscore used as separator for distinction of module name parts
 132         final String moduleName = new StringBuilder(module.getName()).append('_').append(postfix).toString();
 133
 134         final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName);
 135         moduleBuilder.setDescription(createDescription(module, verboseClassComments));
 136         moduleBuilder.setReference(module.getReference());
 137         moduleBuilder.setModuleName(moduleName);
 138
 139         return moduleBuilder;
 140     }
 141
 142     /**
 143      * Adds the implemented types to type builder.
 144      *
 145      * The method passes through the list of <i>uses</i> in
 146      * {@code dataNodeContainer}. For every <i>use</i> is obtained corresponding
 147      * generated type from all groupings
 148      * allGroupings} which is added as <i>implements type</i> to
 149      * <code>builder</code>
 150      *
 151      * @param dataNodeContainer
 152      *            element which contains the list of used YANG groupings
 153      * @param builder
 154      *            builder to which are added implemented types according to
 155      *            <code>dataNodeContainer</code>
 156      * @param genCtx generated context
 157      * @return generated type builder with all implemented types
 158      */
 159     static GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
 160                           final GeneratedTypeBuilder builder, final Map<Module, ModuleContext> genCtx) {
 161         for (final UsesNode usesNode : dataNodeContainer.getUses()) {
 162             final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath(), genCtx).toInstance();
 163             if (genType == null) {
 164                 throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
 165                     + builder.getName());
 166             }
 167             builder.addImplementsType(genType);
 168         }
 169         return builder;
 170     }
 171
 172      static GeneratedTypeBuilder findGroupingByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
 173         for (final ModuleContext ctx : genCtx.values()) {
 174             final GeneratedTypeBuilder result = ctx.getGrouping(path);
 175             if (result != null) {
 176                 return result;
 177             }
 178         }
 179         return null;
 180      }
 181
 182     /**
 183      * Adds the methods to <code>typeBuilder</code> which represent subnodes of
 184      * node for which <code>typeBuilder</code> was created.
 185      *
 186      * The subnodes aren't mapped to the methods if they are part of grouping or
 187      * augment (in this case are already part of them).
 188      *
 189      * @param module
 190      *            current module
 191      * @param basePackageName
 192      *            string contains the module package name
 193      * @param parent
 194      *            generated type builder which represents any node. The subnodes
 195      *            of this node are added to the <code>typeBuilder</code> as
 196      *            methods. The subnode can be of type leaf, leaf-list, list,
 197      *            container, choice.
 198      * @param childOf
 199      *            parent type
 200      * @param schemaNodes
 201      *            set of data schema nodes which are the children of the node
 202      *            for which <code>typeBuilder</code> was created
 203      * @return generated type builder which is the same builder as input
 204      *         parameter. The getter methods (representing child nodes) could be
 205      *         added to it.
 206      */
 207     static GeneratedTypeBuilder resolveDataSchemaNodes(final Module module, final String basePackageName,
 208                           final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf,
 209                           final Iterable<DataSchemaNode> schemaNodes, final Map<Module, ModuleContext> genCtx,
 210                           final SchemaContext schemaContext, final boolean verboseClassComments,
 211                           final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
 212                           final TypeProvider typeProvider) {
 213
 214         if (schemaNodes != null && parent != null) {
 215             for (final DataSchemaNode schemaNode : schemaNodes) {
 216                 if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {
 217                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module, genCtx,
 218                             schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
 219                 }
 220             }
 221         }
 222         return parent;
 223     }
 224
 225     static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode
 226             schemaNode, final Module module, final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext,
 227                                                               final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
 228         return addDefaultInterfaceDefinition(packageName, schemaNode, null, module, genCtx, schemaContext,
 229                 verboseClassComments, genTypeBuilders);
 230     }
 231
 232     static Map<Module, ModuleContext> processUsesAugments(final SchemaContext schemaContext, final
 233                         DataNodeContainer node, final Module module, Map<Module, ModuleContext> genCtx,
 234                         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders,
 235                         final boolean verboseClassComments, final TypeProvider typeProvider) {
 236         final String basePackageName = BindingMapping.getRootPackageName(module);
 237         for (final UsesNode usesNode : node.getUses()) {
 238             for (final AugmentationSchema augment : usesNode.getAugmentations()) {
 239                 genCtx = AugmentToGenType.usesAugmentationToGenTypes(schemaContext, basePackageName, augment, module,
 240                         usesNode, node, genCtx, genTypeBuilders, verboseClassComments, typeProvider);
 241                 genCtx = processUsesAugments(schemaContext, augment, module, genCtx, genTypeBuilders,
 242                         verboseClassComments, typeProvider);
 243             }
 244         }
 245         return genCtx;
 246     }
 247
 248     static GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
 249         for (final ModuleContext ctx : genCtx.values()) {
 250             final GeneratedTypeBuilder result = ctx.getChildNode(path);
 251             if (result != null) {
 252                 return result;
 253             }
 254         }
 255         return null;
 256     }
 257
 258     static GeneratedTypeBuilder findCaseByPath(final SchemaPath path, final Map<Module, ModuleContext> genCtx) {
 259         for (final ModuleContext ctx : genCtx.values()) {
 260             final GeneratedTypeBuilder result = ctx.getCase(path);
 261             if (result != null) {
 262                 return result;
 263             }
 264         }
 265         return null;
 266     }
 267
 268     /**
 269      * Returns a generated type builder for an augmentation.
 270      *
 271      * The name of the type builder is equal to the name of augmented node with
 272      * serial number as suffix.
 273      *
 274      * @param module
 275      *            current module
 276      * @param augmentPackageName
 277      *            string with contains the package name to which the augment
 278      *            belongs
 279      * @param basePackageName
 280      *            string with the package name to which the augmented node
 281      *            belongs
 282      * @param targetTypeRef
 283      *            target type
 284      * @param augSchema
 285      *            augmentation schema which contains data about the child nodes
 286      *            and uses of augment
 287      * @return generated type builder for augment in genCtx
 288      */
 289     static Map<Module, ModuleContext> addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
 290                 final String basePackageName, final Type targetTypeRef, final AugmentationSchema augSchema,
 291                 final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final Map<Module, ModuleContext> genCtx) {
 292
 293         Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);
 294         if (augmentBuilders == null) {
 295             augmentBuilders = new HashMap<>();
 296             genTypeBuilders.put(augmentPackageName, augmentBuilders);
 297         }
 298         String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());
 299
 300         if (augIdentifier == null) {
 301             augIdentifier = augGenTypeName(augmentBuilders, targetTypeRef.getName());
 302         }
 303
 304         GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augIdentifier);
 305
 306         augTypeBuilder.addImplementsType(BindingTypes.TREE_NODE);
 307         augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
 308         annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
 309         augTypeBuilder = addImplementedInterfaceFromUses(augSchema, augTypeBuilder, genCtx);
 310
 311         augTypeBuilder = augSchemaNodeToMethods(module, basePackageName, augTypeBuilder, augTypeBuilder, augSchema
 312                 .getChildNodes());
 313         augmentBuilders.put(augTypeBuilder.getName(), augTypeBuilder);
 314
 315         if(!augSchema.getChildNodes().isEmpty()) {
 316             genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema);
 317
 318         }
 319         genCtx.get(module).addAugmentType(augTypeBuilder);
 320         return genCtx;
 321     }
 322
 323     /**
 324      * Adds the methods to <code>typeBuilder</code> what represents subnodes of
 325      * node for which <code>typeBuilder</code> was created.
 326      *
 327      * @param module
 328      *            current module
 329      * @param basePackageName
 330      *            string contains the module package name
 331      * @param typeBuilder
 332      *            generated type builder which represents any node. The subnodes
 333      *            of this node are added to the <code>typeBuilder</code> as
 334      *            methods. The subnode can be of type leaf, leaf-list, list,
 335      *            container, choice.
 336      * @param childOf
 337      *            parent type
 338      * @param schemaNodes
 339      *            set of data schema nodes which are the children of the node
 340      *            for which <code>typeBuilder</code> was created
 341      * @return generated type builder which is the same object as the input
 342      *         parameter <code>typeBuilder</code>. The getter method could be
 343      *         added to it.
 344      */
 345     private static GeneratedTypeBuilder augSchemaNodeToMethods(final Module module, final String basePackageName,
 346             final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf,
 347             final Iterable<DataSchemaNode> schemaNodes) {
 348         if (schemaNodes != null && typeBuilder != null) {
 349             for (final DataSchemaNode schemaNode : schemaNodes) {
 350                 if (!schemaNode.isAugmenting()) {
 351                     //TODO: design decomposition and implement it
 352                     //addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder, childOf, module);
 353                 }
 354             }
 355         }
 356         return typeBuilder;
 357     }
 358
 359     /**
 360      * Instantiates generated type builder with <code>packageName</code> and
 361      * <code>schemaNode</code>.
 362      *
 363      * The new builder always implements
 364      * {@link TreeNode TreeNode}.<br>
 365      * If <code>schemaNode</code> is instance of GroupingDefinition it also
 366      * implements {@link Augmentable
 367      * Augmentable}.<br>
 368      * If <code>schemaNode</code> is instance of
 369      * {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer
 370      * DataNodeContainer} it can also implement nodes which are specified in
 371      * <i>uses</i>.
 372      *
 373      * @param packageName
 374      *            string with the name of the package to which
 375      *            <code>schemaNode</code> belongs.
 376      * @param schemaNode
 377      *            schema node for which is created generated type builder
 378      * @param parent
 379      *            parent type (can be null)
 380      * @param schemaContext schema context
 381      * @return generated type builder <code>schemaNode</code>
 382      */
 383     static GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode
 384             schemaNode, final Type parent, final Module module, final Map<Module, ModuleContext> genCtx,
 385             final SchemaContext schemaContext, final boolean verboseClassComments, final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
 386
 387         GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, schemaContext, "",
 388                 verboseClassComments, genTypeBuilders);
 389         if (parent == null) {
 390             it.addImplementsType(BindingTypes.TREE_NODE);
 391         } else {
 392             it.addImplementsType(BindingTypes.treeChildNode(parent));
 393         }
 394         if (!(schemaNode instanceof GroupingDefinition)) {
 395             it.addImplementsType(BindingTypes.augmentable(it));
 396         }
 397
 398         if (schemaNode instanceof DataNodeContainer) {
 399             //TODO: design decomposition and implement it
 400             //groupingsToGenTypes(module, ((DataNodeContainer) schemaNode).getGroupings());
 401             it = addImplementedInterfaceFromUses((DataNodeContainer) schemaNode, it, genCtx);
 402         }
 403
 404         return it;
 405     }
 406
 407     static GeneratedTypeBuilder resolveNotification(final GeneratedTypeBuilder listenerInterface, String
 408             parentName, final String basePackageName, final NotificationDefinition notification, final Module module,
 409             final SchemaContext schemaContext, final boolean verboseClassComments, Map<String, Map<String, GeneratedTypeBuilder>>
 410             genTypeBuilders, TypeProvider typeProvider, Map<Module, ModuleContext> genCtx) {
 411
 412         processUsesAugments(schemaContext, notification, module, genCtx, genTypeBuilders,
 413                 verboseClassComments, typeProvider);
 414
 415         final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition
 416                 (basePackageName, notification, null, module, genCtx, schemaContext,
 417                         verboseClassComments, genTypeBuilders);
 418         annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
 419         notificationInterface.addImplementsType(NOTIFICATION);
 420         genCtx.get(module).addChildNodeType(notification, notificationInterface);
 421
 422         // Notification object
 423         resolveDataSchemaNodes(module, basePackageName, notificationInterface,
 424                 notificationInterface, notification.getChildNodes(), genCtx, schemaContext,
 425                 verboseClassComments, genTypeBuilders, typeProvider);
 426
 427         //in case of tied notification, incorporate parent's localName
 428         final StringBuilder sb = new StringBuilder("on_");
 429         if (parentName != null) {
 430             sb.append(parentName).append('_');
 431         }
 432         sb.append(notificationInterface.getName());
 433
 434         listenerInterface.addMethod(NonJavaCharsConverter.convertIdentifier(sb.toString(), JavaIdentifier.METHOD))
 435                 .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
 436                 .setComment(encodeAngleBrackets(notification.getDescription())).setReturnType(Types.VOID);
 437         return listenerInterface;
 438     }
 439
 440     /**
 441      * Returns reference to generated type builder for specified
 442      * <code>schemaNode</code> with <code>packageName</code>.
 443      *
 444      * Firstly the generated type builder is searched in
 445      * {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't
 446      * found it is created and added to <code>genTypeBuilders</code>.
 447      *
 448      * @param packageName
 449      *            string with the package name to which returning generated type
 450      *            builder belongs
 451      * @param schemaNode
 452      *            schema node which provide data about the schema node name
 453      * @param schemaContext
 454      * @param prefix
 455      *            return type name prefix
 456      * @return generated type builder for <code>schemaNode</code>
 457      * @throws IllegalArgumentException
 458      *             <ul>
 459      *             <li>if <code>schemaNode</code> is null</li>
 460      *             <li>if <code>packageName</code> is null</li>
 461      *             <li>if QName of schema node is null</li>
 462      *             <li>if schemaNode name is null</li>
 463      *             </ul>
 464      *
 465      */
 466     static GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
 467                        final SchemaContext schemaContext, final String prefix, final boolean verboseClassComments,
 468                        final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders) {
 469
 470         Preconditions.checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
 471         Preconditions.checkArgument(packageName != null, "Package Name for Generated Type cannot be NULL.");
 472         String schemaNodeName = schemaNode.getQName().getLocalName();
 473         Preconditions.checkArgument(schemaNodeName != null, "Local Name of QName for Data Schema Node cannot be NULL.");
 474
 475         if (prefix != null && !prefix.isEmpty()) {
 476             // underscore used as separator for distinction of class name parts
 477             schemaNodeName = new StringBuilder(prefix).append('_').append(schemaNodeName).toString();
 478         }
 479
 480         final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, schemaNodeName);
 481         final Module module = SchemaContextUtil.findParentModule(schemaContext, schemaNode);
 482         qNameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
 483         newType.addComment(schemaNode.getDescription());
 484         newType.setDescription(createDescription(schemaNode, newType.getFullyQualifiedName(), schemaContext, verboseClassComments));
 485         newType.setReference(schemaNode.getReference());
 486         newType.setSchemaPath((List<QName>) schemaNode.getPath().getPathFromRoot());
 487         newType.setModuleName(module.getName());
 488
 489         if (!genTypeBuilders.containsKey(packageName)) {
 490             final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
 491             builders.put(newType.getName(), newType);
 492             genTypeBuilders.put(packageName, builders);
 493         } else {
 494             final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
 495             if (!builders.containsKey(newType.getName())) {
 496                 builders.put(newType.getName(), newType);
 497             }
 498         }
 499         return newType;
 500
 501     }
 502
 503     private static void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode node,
 504         final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Module module,
 505         final Map<Module, ModuleContext> genCtx, final SchemaContext schemaContext, final boolean verboseClassComments,
 506         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
 507         //TODO: implement rest of schema nodes GTO building
 508         if (node != null && typeBuilder != null) {
 509             if (node instanceof ContainerSchemaNode) {
 510                 containerToGenType(module, basePackageName, typeBuilder, childOf, (ContainerSchemaNode) node,
 511                         schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
 512             } else if (node instanceof LeafSchemaNode) {
 513                 resolveLeafSchemaNodeAsMethod(schemaContext, typeBuilder, genCtx, (LeafSchemaNode) node, module,
 514                         typeProvider);
 515             } else if (node instanceof ListSchemaNode) {
 516                 listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node, schemaContext,
 517                         verboseClassComments, genCtx, genTypeBuilders, typeProvider);
 518             }
 519         }
 520
 521     }
 522
 523     private static void containerToGenType(final Module module, final String basePackageName,
 524         final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ContainerSchemaNode node,
 525         final SchemaContext schemaContext, final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
 526         final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
 527
 528         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
 529                 schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
 530         if (genType != null) {
 531             constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), genType, node.getStatus());
 532             resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes(), genCtx,
 533                     schemaContext, verboseClassComments, genTypeBuilders, typeProvider);
 534         }
 535     }
 536
 537     private static void listToGenType(final Module module, final String basePackageName, final GeneratedTypeBuilder
 538             parent, final GeneratedTypeBuilder childOf, final ListSchemaNode node, final SchemaContext schemaContext,
 539             final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx,
 540             final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
 541         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node,
 542                 schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
 543         if (genType != null) {
 544             final String nodeName = node.getQName().getLocalName();
 545             constructGetter(parent, nodeName, node.getDescription(),
 546                     Types.listTypeFor(genType), node.getStatus());
 547             final List<QName> listKeys = node.getKeyDefinition();
 548             final String packageName = new StringBuilder(packageNameForGeneratedType(basePackageName, node.getPath(),
 549                     BindingNamespaceType.Key)).append('.').append(nodeName).toString();
 550
 551             final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node);
 552
 553             for (final DataSchemaNode schemaNode : node.getChildNodes()) {
 554                 if (!schemaNode.isAugmenting()) {
 555                     addSchemaNodeToListBuilders(nodeName, basePackageName, schemaNode, genType, genTOBuilder, listKeys,
 556                             module, typeProvider, schemaContext, genCtx, genTypeBuilders, verboseClassComments);
 557                 }
 558             }
 559
 560             // serialVersionUID
 561             if (genTOBuilder != null) {
 562                 final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
 563                 prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder)));
 564                 genTOBuilder.setSUID(prop);
 565             }
 566
 567             typeBuildersToGenTypes(module, genType, genTOBuilder, genCtx);
 568         }
 569     }
 570
 571     private static void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder,
 572             final GeneratedTOBuilder genTOBuilder, final Map<Module, ModuleContext> genCtx) {
 573         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
 574         if (genTOBuilder != null) {
 575             final GeneratedTransferObject genTO = genTOBuilder.toInstance();
 576             constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO, Status.CURRENT);
 577             genCtx.get(module).addGeneratedTOBuilder(genTOBuilder);
 578         }
 579     }
 580
 581     /**
 582      * Converts <code>leaf</code> to the getter method which is added to
 583      * <code>typeBuilder</code>.
 584      *
 585      * @param typeBuilder
 586      *            generated type builder to which is added getter method as
 587      *            <code>leaf</code> mapping
 588      * @param leaf
 589      *            leaf schema node which is mapped as getter method which is
 590      *            added to <code>typeBuilder</code>
 591      * @param module
 592      *            Module in which type was defined
 593      * @return boolean value
 594      *         <ul>
 595      *         <li>false - if <code>leaf</code> or <code>typeBuilder</code> are
 596      *         null</li>
 597      *         <li>true - in other cases</li>
 598      *         </ul>
 599      */
 600     private static Type resolveLeafSchemaNodeAsMethod(final SchemaContext schemaContext, final GeneratedTypeBuilder
 601             typeBuilder, final Map<Module, ModuleContext> genCtx, final LeafSchemaNode leaf, final Module module,
 602             final TypeProvider typeProvider) {
 603         if (leaf == null || typeBuilder == null || leaf.isAddedByUses()) {
 604             return null;
 605         }
 606
 607         final String leafName = leaf.getQName().getLocalName();
 608         if (leafName == null) {
 609             return null;
 610         }
 611
 612         final Module parentModule = findParentModule(schemaContext, leaf);
 613         Type returnType = null;
 614
 615         final TypeDefinition<?> typeDef = leaf.getType();
 616         if (isInnerType(leaf, typeDef)) {
 617             if (typeDef instanceof EnumTypeDefinition) {
 618                 returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
 619                 final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
 620                 final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(),
 621                         genCtx, typeBuilder, module);
 622                 if (enumBuilder != null) {
 623                     returnType = enumBuilder.toInstance(typeBuilder);
 624                 }
 625                 ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
 626             } else if (typeDef instanceof UnionTypeDefinition) {
 627                 final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
 628                         typeProvider, schemaContext);
 629                 if (genTOBuilder != null) {
 630                     //TODO: https://bugs.opendaylight.org/show_bug.cgi?id=2289
 631                     returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule, typeProvider);
 632                 }
 633             } else if (typeDef instanceof BitsTypeDefinition) {
 634                 final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule,
 635                         typeProvider, schemaContext);
 636                 if (genTOBuilder != null) {
 637                     returnType = genTOBuilder.toInstance();
 638                 }
 639             } else {
 640                 // It is constrained version of already declared type (inner declared type exists,
 641                 // onlyfor special cases (Enum, Union, Bits), which were already checked.
 642                 // In order to get proper class we need to look up closest derived type
 643                 // and apply restrictions from leaf type
 644                 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
 645                 returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf,
 646                         restrictions);
 647             }
 648         } else {
 649             final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
 650             returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions);
 651         }
 652
 653         if (returnType == null) {
 654             return null;
 655         }
 656
 657         if (typeDef instanceof EnumTypeDefinition) {
 658             ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
 659         }
 660
 661         String leafDesc = leaf.getDescription();
 662         if (leafDesc == null) {
 663             leafDesc = "";
 664         }
 665
 666         constructGetter(typeBuilder, leafName, leafDesc, returnType, leaf.getStatus());
 667         genCtx.get(module).addChildNodeType(leaf, typeBuilder);
 668         return returnType;
 669     }
 670
 671     /**
 672      * Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method
 673      * or to <code>genTOBuilder</code> as property.
 674      *
 675      * @param nodeName
 676      *            string contains the name of list
 677      * @param basePackageName
 678      *            string contains the module package name
 679      * @param schemaNode
 680      *            data schema node which should be added as getter method to
 681      *            <code>typeBuilder</code> or as a property to
 682      *            <code>genTOBuilder</code> if is part of the list key
 683      * @param typeBuilder
 684      *            generated type builder for the list schema node
 685      * @param genTOBuilder
 686      *            generated TO builder for the list keys
 687      * @param listKeys
 688      *            list of string which contains QNames of the list keys
 689      * @param module
 690      *            current module
 691      * @param typeProvider
 692      *            provider that defines contract for generated types
 693      * @param schemaContext
 694      *            schema context
 695      * @param genCtx
 696      *            map of generated entities in context of YANG modules
 697      * @param genTypeBuilders
 698      *            map of generated type builders
 699      * @param verboseClassComments
 700      *            generate verbose comments
 701      * @throws IllegalArgumentException
 702      *             <ul>
 703      *             <li>if <code>schemaNode</code> equals null</li>
 704      *             <li>if <code>typeBuilder</code> equals null</li>
 705      *             </ul>
 706      */
 707     private static void addSchemaNodeToListBuilders(final String nodeName, final String basePackageName,
 708             final DataSchemaNode schemaNode, final GeneratedTypeBuilder typeBuilder,
 709             final GeneratedTOBuilder genTOBuilder, final List<QName> listKeys, final Module module,
 710             final TypeProvider typeProvider, final SchemaContext schemaContext, final Map<Module, ModuleContext> genCtx,
 711             final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders, final boolean verboseClassComments) {
 712         checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
 713         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
 714
 715         if (schemaNode instanceof LeafSchemaNode) {
 716             final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
 717             final QName leafQName = leaf.getQName();
 718             final String leafName = leafQName.getLocalName();
 719             String leafPckgName = basePackageName;
 720             boolean isKeyPart = false;
 721             if (listKeys.contains(leafQName)) {
 722                 leafPckgName = new StringBuilder(leafPckgName).append('.').append(BindingNamespaceType.Key).append('.')
 723                         .append(nodeName).toString();
 724                 isKeyPart = true;
 725             } else {
 726                 leafPckgName = new StringBuilder(leafPckgName).append('.').append(BindingNamespaceType.Data).append('.')
 727                         .append(nodeName).toString();
 728             }
 729
 730             final String leafGTOName = new StringBuilder(nodeName).append('_').append(leafName).toString();
 731             final GeneratedTypeBuilder leafGTp = new GeneratedTypeBuilderImpl(leafPckgName, leafGTOName);
 732             resolveLeafSchemaNodeAsMethod(schemaContext, leafGTp, genCtx, leaf, module,
 733                     typeProvider);
 734
 735             constructGetter(typeBuilder, leafGTOName, schemaNode.getDescription(), leafGTp, Status.CURRENT);
 736
 737             if (isKeyPart) {
 738                 AuxiliaryGenUtils.resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, leafGTp, true);
 739             }
 740         } else if (!schemaNode.isAddedByUses()) {
 741             //TODO: implement leaf list to generated type
 742             //TODO: implement choice to generated type
 743             if (schemaNode instanceof ContainerSchemaNode) {
 744                 containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode,
 745                         schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
 746             } else if (schemaNode instanceof ListSchemaNode) {
 747                 listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode,
 748                         schemaContext, verboseClassComments, genCtx, genTypeBuilders, typeProvider);
 749             }
 750         }
 751     }
 752
 753     private static TypeDefinition<?> getBaseOrDeclaredType(final TypeDefinition<?> typeDef) {
 754         final TypeDefinition<?> baseType = typeDef.getBaseType();
 755         return (baseType != null && baseType.getBaseType() != null) ? baseType : typeDef;
 756     }
 757
 758     @SuppressWarnings({ "rawtypes", "unchecked" })
 759     private static GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
 760         final GeneratedTypeBuilder childOf, final DataSchemaNode node, final SchemaContext schemaContext,
 761         final boolean verboseClassComments, final Map<Module, ModuleContext> genCtx, final Map<String, Map<String,
 762         GeneratedTypeBuilder>> genTypeBuilders, final TypeProvider typeProvider) {
 763
 764         if (node.isAugmenting() || node.isAddedByUses()) {
 765             return null;
 766         }
 767         final String packageName = packageNameForGeneratedType(basePackageName, node.getPath(), BindingNamespaceType.Data);
 768         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf, module,
 769                 genCtx, schemaContext, verboseClassComments, genTypeBuilders);
 770         genType.addComment(node.getDescription());
 771         annotateDeprecatedIfNecessary(node.getStatus(), genType);
 772         genType.setDescription(createDescription(node, genType.getFullyQualifiedName(), schemaContext, verboseClassComments));
 773         genType.setModuleName(module.getName());
 774         genType.setReference(node.getReference());
 775         genType.setSchemaPath((List) node.getPath().getPathFromRoot());
 776         if (node instanceof DataNodeContainer) {
 777             genCtx.get(module).addChildNodeType(node, genType);
 778             //TODO: implement groupings to GTO building first
 779             // groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings());
 780             processUsesAugments(schemaContext, (DataNodeContainer) node, module, genCtx, genTypeBuilders,
 781                     verboseClassComments, typeProvider);
 782         }
 783         return genType;
 784     }
 785 }