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