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

   1 /*
   2  * Copyright (c) 2013 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 package org.opendaylight.yangtools.sal.binding.generator.impl;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11 import static com.google.common.base.Preconditions.checkNotNull;
  12 import static com.google.common.base.Preconditions.checkState;
  13 import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.computeDefaultSUID;
  14 import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.packageNameForGeneratedType;
  15 import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.parseToValidParamName;
  16 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.DATA_OBJECT;
  17 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.DATA_ROOT;
  18 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.IDENTIFIABLE;
  19 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.IDENTIFIER;
  20 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.NOTIFICATION;
  21 import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.augmentable;
  22 import static org.opendaylight.yangtools.binding.generator.util.Types.BOOLEAN;
  23 import static org.opendaylight.yangtools.binding.generator.util.Types.FUTURE;
  24 import static org.opendaylight.yangtools.binding.generator.util.Types.VOID;
  25 import static org.opendaylight.yangtools.binding.generator.util.Types.typeForClass;
  26 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
  27 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findNodeInSchemaContext;
  28 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
  29
  30 import com.google.common.base.Splitter;
  31 import com.google.common.collect.Iterables;
  32 import com.google.common.collect.Sets;
  33 import java.util.ArrayList;
  34 import java.util.Collection;
  35 import java.util.Collections;
  36 import java.util.HashMap;
  37 import java.util.Iterator;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Set;
  41 import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
  42 import org.opendaylight.yangtools.binding.generator.util.BindingTypes;
  43 import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;
  44 import org.opendaylight.yangtools.binding.generator.util.Types;
  45 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedPropertyBuilderImpl;
  46 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
  47 import org.opendaylight.yangtools.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
  48 import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;
  49 import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;
  50 import org.opendaylight.yangtools.sal.binding.model.api.AccessModifier;
  51 import org.opendaylight.yangtools.sal.binding.model.api.Constant;
  52 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;
  53 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
  54 import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType;
  55 import org.opendaylight.yangtools.sal.binding.model.api.Restrictions;
  56 import org.opendaylight.yangtools.sal.binding.model.api.Type;
  57 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
  58 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;
  59 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
  60 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
  61 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
  62 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
  63 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;
  64 import org.opendaylight.yangtools.sal.binding.yang.types.GroupingDefinitionDependencySort;
  65 import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl;
  66 import org.opendaylight.yangtools.yang.binding.BaseIdentity;
  67 import org.opendaylight.yangtools.yang.binding.BindingMapping;
  68 import org.opendaylight.yangtools.yang.binding.DataContainer;
  69 import org.opendaylight.yangtools.yang.binding.RpcService;
  70 import org.opendaylight.yangtools.yang.binding.annotations.RoutingContext;
  71 import org.opendaylight.yangtools.yang.common.QName;
  72 import org.opendaylight.yangtools.yang.common.RpcResult;
  73 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  74 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  75 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
  76 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  77 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
  78 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  79 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
  80 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  81 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
  82 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
  83 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  84 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
  85 import org.opendaylight.yangtools.yang.model.api.Module;
  86 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
  87 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  88 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  89 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  90 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
  91 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  92 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  93 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  94 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  95 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
  96 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
  97 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
  98 import org.opendaylight.yangtools.yang.model.util.DataNodeIterator;
  99 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
 100 import org.opendaylight.yangtools.yang.model.util.UnionType;
 101 import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
 102 import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
 103 import org.slf4j.Logger;
 104 import org.slf4j.LoggerFactory;
 105
 106 public class BindingGeneratorImpl implements BindingGenerator {
 107     private static final Logger LOG = LoggerFactory.getLogger(BindingGeneratorImpl.class);
 108     private static final Splitter COLON_SPLITTER = Splitter.on(':');
 109     private static final Splitter BSDOT_SPLITTER = Splitter.on("\\.");
 110     private static final char NEW_LINE = '\n';
 111
 112     /**
 113      * Constant with the concrete name of identifier.
 114      */
 115     private static final String AUGMENT_IDENTIFIER_NAME = "augment-identifier";
 116
 117     /**
 118      * Constant with the concrete name of namespace.
 119      */
 120     private static final String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";
 121
 122     private final Map<Module, ModuleContext> genCtx = new HashMap<>();
 123
 124     /**
 125      * When set to true, generated classes will include javadoc comments which
 126      * are useful for users.
 127      */
 128     private final boolean verboseClassComments;
 129
 130     /**
 131      * Outer key represents the package name. Outer value represents map of all
 132      * builders in the same package. Inner key represents the schema node name
 133      * (in JAVA class/interface name format). Inner value represents instance of
 134      * builder for schema node specified in key part.
 135      */
 136     private Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders;
 137
 138     /**
 139      * Provide methods for converting YANG types to JAVA types.
 140      */
 141     private TypeProvider typeProvider;
 142
 143     /**
 144      * Holds reference to schema context to resolve data of augmented element
 145      * when creating augmentation builder
 146      */
 147     private SchemaContext schemaContext;
 148
 149     /**
 150      * Create a new binding generator with verboe comments.
 151      *
 152      * @deprecated Use {@link #BindingGeneratorImpl(boolean)} instead.
 153      */
 154     @Deprecated
 155     public BindingGeneratorImpl() {
 156         this(true);
 157     }
 158
 159     /**
 160      * Create a new binding generator.
 161      *
 162      * @param verboseClassComments generate verbose comments
 163      */
 164     public BindingGeneratorImpl(final boolean verboseClassComments) {
 165         this.verboseClassComments = verboseClassComments;
 166     }
 167
 168     /**
 169      * Resolves generated types from <code>context</code> schema nodes of all
 170      * modules.
 171      *
 172      * Generated types are created for modules, groupings, types, containers,
 173      * lists, choices, augments, rpcs, notification, identities.
 174      *
 175      * @param context
 176      *            schema context which contains data about all schema nodes
 177      *            saved in modules
 178      * @return list of types (usually <code>GeneratedType</code>
 179      *         <code>GeneratedTransferObject</code>which are generated from
 180      *         <code>context</code> data.
 181      * @throws IllegalArgumentException
 182      *             if arg <code>context</code> is null
 183      * @throws IllegalStateException
 184      *             if <code>context</code> contain no modules
 185      */
 186     @Override
 187     public List<Type> generateTypes(final SchemaContext context) {
 188         checkArgument(context != null, "Schema Context reference cannot be NULL.");
 189         checkState(context.getModules() != null, "Schema Context does not contain defined modules.");
 190         schemaContext = context;
 191         typeProvider = new TypeProviderImpl(context);
 192         final Set<Module> modules = context.getModules();
 193         return generateTypes(context, modules);
 194     }
 195
 196     /**
 197      * Resolves generated types from <code>context</code> schema nodes only for
 198      * modules specified in <code>modules</code>
 199      *
 200      * Generated types are created for modules, groupings, types, containers,
 201      * lists, choices, augments, rpcs, notification, identities.
 202      *
 203      * @param context
 204      *            schema context which contains data about all schema nodes
 205      *            saved in modules
 206      * @param modules
 207      *            set of modules for which schema nodes should be generated
 208      *            types
 209      * @return list of types (usually <code>GeneratedType</code> or
 210      *         <code>GeneratedTransferObject</code>) which:
 211      *         <ul>
 212      *         <li>are generated from <code>context</code> schema nodes and</li>
 213      *         <li>are also part of some of the module in <code>modules</code>
 214      *         set</li>.
 215      *         </ul>
 216      * @throws IllegalArgumentException
 217      *             <ul>
 218      *             <li>if arg <code>context</code> is null or</li>
 219      *             <li>if arg <code>modules</code> is null</li>
 220      *             </ul>
 221      * @throws IllegalStateException
 222      *             if <code>context</code> contain no modules
 223      */
 224     @Override
 225     public List<Type> generateTypes(final SchemaContext context, final Set<Module> modules) {
 226         checkArgument(context != null, "Schema Context reference cannot be NULL.");
 227         checkState(context.getModules() != null, "Schema Context does not contain defined modules.");
 228         checkArgument(modules != null, "Set of Modules cannot be NULL.");
 229
 230         schemaContext = context;
 231         typeProvider = new TypeProviderImpl(context);
 232         Module[] modulesArray = new Module[context.getModules().size()];
 233         context.getModules().toArray(modulesArray);
 234         final List<Module> contextModules = ModuleDependencySort.sort(modulesArray);
 235         genTypeBuilders = new HashMap<>();
 236
 237         for (Module contextModule : contextModules) {
 238             moduleToGenTypes(contextModule, context);
 239         }
 240         for (Module contextModule : contextModules) {
 241             allAugmentsToGenTypes(contextModule);
 242         }
 243
 244         final List<Type> filteredGenTypes = new ArrayList<>();
 245         for (Module m : modules) {
 246             final ModuleContext ctx = checkNotNull(genCtx.get(m), "Module context not found for module %s", m);
 247             filteredGenTypes.addAll(ctx.getGeneratedTypes());
 248             final Set<Type> additionalTypes = ((TypeProviderImpl) typeProvider).getAdditionalTypes().get(m);
 249             if (additionalTypes != null) {
 250                 filteredGenTypes.addAll(additionalTypes);
 251             }
 252         }
 253
 254         return filteredGenTypes;
 255     }
 256
 257     private void moduleToGenTypes(final Module m, final SchemaContext context) {
 258         genCtx.put(m, new ModuleContext());
 259         allTypeDefinitionsToGenTypes(m);
 260         groupingsToGenTypes(m, m.getGroupings());
 261         rpcMethodsToGenType(m);
 262         allIdentitiesToGenTypes(m, context);
 263         notificationsToGenType(m);
 264
 265         if (!m.getChildNodes().isEmpty()) {
 266             final GeneratedTypeBuilder moduleType = moduleToDataType(m);
 267             genCtx.get(m).addModuleNode(moduleType);
 268             final String basePackageName = BindingMapping.getRootPackageName(m.getQNameModule());
 269             resolveDataSchemaNodes(m, basePackageName, moduleType, moduleType, m.getChildNodes());
 270         }
 271     }
 272
 273     /**
 274      * Converts all extended type definitions of module to the list of
 275      * <code>Type</code> objects.
 276      *
 277      * @param module
 278      *            module from which is obtained set of type definitions
 279      * @throws IllegalArgumentException
 280      *             <ul>
 281      *             <li>if module is null</li>
 282      *             <li>if name of module is null</li>
 283      *             </ul>
 284      * @throws IllegalStateException
 285      *             if set of type definitions from module is null
 286      */
 287     private void allTypeDefinitionsToGenTypes(final Module module) {
 288         checkArgument(module != null, "Module reference cannot be NULL.");
 289         checkArgument(module.getName() != null, "Module name cannot be NULL.");
 290         final DataNodeIterator it = new DataNodeIterator(module);
 291         final List<TypeDefinition<?>> typeDefinitions = it.allTypedefs();
 292         checkState(typeDefinitions != null, "Type Definitions for module «module.name» cannot be NULL.");
 293
 294         for (TypeDefinition<?> typedef : typeDefinitions) {
 295             if (typedef != null) {
 296                 final Type type = ((TypeProviderImpl) typeProvider).generatedTypeForExtendedDefinitionType(typedef,
 297                         typedef);
 298                 if (type != null) {
 299                     genCtx.get(module).addTypedefType(typedef.getPath(), type);
 300                 }
 301             }
 302         }
 303     }
 304
 305     private GeneratedTypeBuilder processDataSchemaNode(final Module module, final String basePackageName,
 306             final GeneratedTypeBuilder childOf, final DataSchemaNode node) {
 307         if (node.isAugmenting() || node.isAddedByUses()) {
 308             return null;
 309         }
 310         final String packageName = packageNameForGeneratedType(basePackageName, node.getPath());
 311         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, node, childOf, module);
 312         genType.addComment(node.getDescription());
 313         genType.setDescription(createDescription(node, genType.getFullyQualifiedName()));
 314         genType.setModuleName(module.getName());
 315         genType.setReference(node.getReference());
 316         genType.setSchemaPath(node.getPath().getPathFromRoot());
 317         if (node instanceof DataNodeContainer) {
 318             genCtx.get(module).addChildNodeType(node, genType);
 319             groupingsToGenTypes(module, ((DataNodeContainer) node).getGroupings());
 320             processUsesAugments((DataNodeContainer) node, module);
 321             if (node.isAddedByUses() || node.isAugmenting())
 322                 genType.setSuitableForBoxing(false);
 323         }
 324         return genType;
 325     }
 326
 327     private boolean hasWhenOrMustConstraints(final SchemaNode node) {
 328         boolean hasWhenCondition;
 329         boolean hasMustConstraints;
 330
 331         if (node instanceof ContainerSchemaNode) {
 332             ContainerSchemaNode contNode = (ContainerSchemaNode)node;
 333             hasWhenCondition = contNode.getConstraints().getWhenCondition() != null;
 334             hasMustConstraints = !isNullOrEmpty(contNode.getConstraints().getMustConstraints());
 335
 336             if (hasWhenCondition || hasMustConstraints)
 337                 return true;
 338         }
 339         return false;
 340     }
 341
 342     private void containerToGenType(final Module module, final String basePackageName,
 343             final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ContainerSchemaNode node) {
 344         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node);
 345
 346         if (genType != null) {
 347             constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), genType);
 348             resolveDataSchemaNodes(module, basePackageName, genType, genType, node.getChildNodes());
 349
 350             final String parentName = parent.getName();
 351             final String childOfName = childOf.getName();
 352
 353             if (parent != null && !parent.getName().contains("Data"))
 354                 genType.setParentType(parent);
 355             genType.setSuitableForBoxing(hasOnlyOneChild(node) && !hasWhenOrMustConstraints(node));
 356
 357             if (parentName.equals(childOfName))
 358                 genType.setSuitableForBoxing(false);
 359         }
 360     }
 361
 362     private boolean hasOnlyOneChild(final ContainerSchemaNode contNode) {
 363         if (!isNullOrEmpty(contNode.getChildNodes()) && contNode.getChildNodes().size() == 1)
 364             return true;
 365         return false;
 366     }
 367
 368     private void listToGenType(final Module module, final String basePackageName, final GeneratedTypeBuilder parent,
 369             final GeneratedTypeBuilder childOf, final ListSchemaNode node) {
 370         final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node);
 371
 372         if (genType != null) {
 373             if (!parent.getName().equals(childOf) && !parent.getName().contains("Data")) {
 374                 genType.setParentType(parent);
 375             }
 376             constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), Types.listTypeFor(genType));
 377
 378             final List<String> listKeys = listKeys(node);
 379             final String packageName = packageNameForGeneratedType(basePackageName, node.getPath());
 380             final GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, node);
 381             if (genTOBuilder != null) {
 382                 final Type identifierMarker = Types.parameterizedTypeFor(IDENTIFIER, genType);
 383                 final Type identifiableMarker = Types.parameterizedTypeFor(IDENTIFIABLE, genTOBuilder);
 384                 genTOBuilder.addImplementsType(identifierMarker);
 385                 genType.addImplementsType(identifiableMarker);
 386             }
 387
 388             for (DataSchemaNode schemaNode : node.getChildNodes()) {
 389                 if (!schemaNode.isAugmenting()) {
 390                     addSchemaNodeToListBuilders(basePackageName, schemaNode, genType, genTOBuilder, listKeys, module);
 391                 }
 392             }
 393
 394             // serialVersionUID
 395             if (genTOBuilder != null) {
 396                 final GeneratedPropertyBuilder prop = new GeneratedPropertyBuilderImpl("serialVersionUID");
 397                 prop.setValue(Long.toString(computeDefaultSUID(genTOBuilder)));
 398                 genTOBuilder.setSUID(prop);
 399             }
 400
 401             typeBuildersToGenTypes(module, genType, genTOBuilder);
 402         }
 403     }
 404
 405     private void processUsesAugments(final DataNodeContainer node, final Module module) {
 406         final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
 407         for (UsesNode usesNode : node.getUses()) {
 408             for (AugmentationSchema augment : usesNode.getAugmentations()) {
 409                 usesAugmentationToGenTypes(basePackageName, augment, module, usesNode, node);
 410                 processUsesAugments(augment, module);
 411             }
 412         }
 413     }
 414
 415     /**
 416      * Converts all <b>augmentation</b> of the module to the list
 417      * <code>Type</code> objects.
 418      *
 419      * @param module
 420      *            module from which is obtained list of all augmentation objects
 421      *            to iterate over them
 422      * @throws IllegalArgumentException
 423      *             <ul>
 424      *             <li>if the module is null</li>
 425      *             <li>if the name of module is null</li>
 426      *             </ul>
 427      * @throws IllegalStateException
 428      *             if set of augmentations from module is null
 429      */
 430     private void allAugmentsToGenTypes(final Module module) {
 431         checkArgument(module != null, "Module reference cannot be NULL.");
 432         checkArgument(module.getName() != null, "Module name cannot be NULL.");
 433         checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
 434
 435         final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
 436         final List<AugmentationSchema> augmentations = resolveAugmentations(module);
 437         for (AugmentationSchema augment : augmentations) {
 438             augmentationToGenTypes(basePackageName, augment, module);
 439         }
 440     }
 441
 442     /**
 443      * Returns list of <code>AugmentationSchema</code> objects. The objects are
 444      * sorted according to the length of their target path from the shortest to
 445      * the longest.
 446      *
 447      * @param module
 448      *            module from which is obtained list of all augmentation objects
 449      * @return list of sorted <code>AugmentationSchema</code> objects obtained
 450      *         from <code>module</code>
 451      * @throws IllegalArgumentException
 452      *             if module is null
 453      * @throws IllegalStateException
 454      *             if set of module augmentations is null
 455      */
 456     private List<AugmentationSchema> resolveAugmentations(final Module module) {
 457         checkArgument(module != null, "Module reference cannot be NULL.");
 458         checkState(module.getAugmentations() != null, "Augmentations Set cannot be NULL.");
 459
 460         final Set<AugmentationSchema> augmentations = module.getAugmentations();
 461         List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);
 462         Collections.sort(sortedAugmentations, Comparators.AUGMENT_COMP);
 463
 464         return sortedAugmentations;
 465     }
 466
 467     /**
 468      * Create GeneratedTypeBuilder object from module argument.
 469      *
 470      * @param module
 471      *            Module object from which builder will be created
 472      * @return <code>GeneratedTypeBuilder</code> which is internal
 473      *         representation of the module
 474      * @throws IllegalArgumentException
 475      *             if module is null
 476      */
 477     private GeneratedTypeBuilder moduleToDataType(final Module module) {
 478         checkArgument(module != null, "Module reference cannot be NULL.");
 479
 480         final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data");
 481         addImplementedInterfaceFromUses(module, moduleDataTypeBuilder);
 482         moduleDataTypeBuilder.addImplementsType(DATA_ROOT);
 483         moduleDataTypeBuilder.addComment(module.getDescription());
 484         moduleDataTypeBuilder.setDescription(createDescription(module));
 485         moduleDataTypeBuilder.setReference(module.getReference());
 486         return moduleDataTypeBuilder;
 487     }
 488
 489     /**
 490      * Converts all <b>rpcs</b> inputs and outputs substatements of the module
 491      * to the list of <code>Type</code> objects. In addition are to containers
 492      * and lists which belong to input or output also part of returning list.
 493      *
 494      * @param module
 495      *            module from which is obtained set of all rpc objects to
 496      *            iterate over them
 497      * @throws IllegalArgumentException
 498      *             <ul>
 499      *             <li>if the module is null</li>
 500      *             <li>if the name of module is null</li>
 501      *             </ul>
 502      * @throws IllegalStateException
 503      *             if set of rpcs from module is null
 504      */
 505     private void rpcMethodsToGenType(final Module module) {
 506         checkArgument(module != null, "Module reference cannot be NULL.");
 507         checkArgument(module.getName() != null, "Module name cannot be NULL.");
 508         final Set<RpcDefinition> rpcDefinitions = module.getRpcs();
 509         checkState(rpcDefinitions != null, "Set of rpcs from module " + module.getName() + " cannot be NULL.");
 510         if (rpcDefinitions.isEmpty()) {
 511             return;
 512         }
 513
 514         final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
 515         final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(module, "Service");
 516         interfaceBuilder.addImplementsType(Types.typeForClass(RpcService.class));
 517         interfaceBuilder.setDescription(createDescription(rpcDefinitions, module.getName(), module.getModuleSourcePath()));
 518
 519         for (RpcDefinition rpc : rpcDefinitions) {
 520             if (rpc != null) {
 521                 final String rpcName = BindingMapping.getClassName(rpc.getQName());
 522                 final String rpcMethodName = parseToValidParamName(rpcName);
 523                 final String rpcComment = rpc.getDescription();
 524                 final MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);
 525                 final ContainerSchemaNode input = rpc.getInput();
 526                 final ContainerSchemaNode output = rpc.getOutput();
 527
 528                 if (input != null) {
 529                     final GeneratedTypeBuilder inType = addRawInterfaceDefinition(basePackageName, input, rpcName);
 530                     addImplementedInterfaceFromUses(input, inType);
 531                     inType.addImplementsType(DATA_OBJECT);
 532                     inType.addImplementsType(augmentable(inType));
 533                     resolveDataSchemaNodes(module, basePackageName, inType, inType, input.getChildNodes());
 534                     genCtx.get(module).addChildNodeType(input, inType);
 535                     final GeneratedType inTypeInstance = inType.toInstance();
 536                     method.addParameter(inTypeInstance, "input");
 537                 }
 538
 539                 Type outTypeInstance = VOID;
 540                 if (output != null) {
 541                     final GeneratedTypeBuilder outType = addRawInterfaceDefinition(basePackageName, output, rpcName);
 542                     addImplementedInterfaceFromUses(output, outType);
 543                     outType.addImplementsType(DATA_OBJECT);
 544                     outType.addImplementsType(augmentable(outType));
 545                     resolveDataSchemaNodes(module, basePackageName, outType, outType, output.getChildNodes());
 546                     genCtx.get(module).addChildNodeType(output, outType);
 547                     outTypeInstance = outType.toInstance();
 548                 }
 549
 550                 final Type rpcRes = Types.parameterizedTypeFor(Types.typeForClass(RpcResult.class), outTypeInstance);
 551                 method.setComment(rpcComment);
 552                 method.setReturnType(Types.parameterizedTypeFor(FUTURE, rpcRes));
 553             }
 554         }
 555
 556         genCtx.get(module).addTopLevelNodeType(interfaceBuilder);
 557     }
 558
 559     /**
 560      * Converts all <b>notifications</b> of the module to the list of
 561      * <code>Type</code> objects. In addition are to this list added containers
 562      * and lists which are part of this notification.
 563      *
 564      * @param module
 565      *            module from which is obtained set of all notification objects
 566      *            to iterate over them
 567      * @throws IllegalArgumentException
 568      *             <ul>
 569      *             <li>if the module equals null</li>
 570      *             <li>if the name of module equals null</li>
 571      *             </ul>
 572      * @throws IllegalStateException
 573      *             if set of notifications from module is null
 574      */
 575     private void notificationsToGenType(final Module module) {
 576         checkArgument(module != null, "Module reference cannot be NULL.");
 577         checkArgument(module.getName() != null, "Module name cannot be NULL.");
 578         final Set<NotificationDefinition> notifications = module.getNotifications();
 579         checkState(notifications != null, "Set of notification from module " + module.getName() + " cannot be NULL.");
 580         if (notifications.isEmpty()) {
 581             return;
 582         }
 583
 584         final GeneratedTypeBuilder listenerInterface = moduleTypeBuilder(module, "Listener");
 585         listenerInterface.addImplementsType(BindingTypes.NOTIFICATION_LISTENER);
 586         final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
 587
 588
 589
 590         for (NotificationDefinition notification : notifications) {
 591             if (notification != null) {
 592                 processUsesAugments(notification, module);
 593
 594                 final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(basePackageName,
 595                         notification, BindingTypes.DATA_OBJECT, module);
 596                 notificationInterface.addImplementsType(NOTIFICATION);
 597                 genCtx.get(module).addChildNodeType(notification, notificationInterface);
 598
 599                 // Notification object
 600                 resolveDataSchemaNodes(module, basePackageName, notificationInterface, notificationInterface,
 601                         notification.getChildNodes());
 602
 603                 listenerInterface.addMethod("on" + notificationInterface.getName())
 604                 .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
 605                 .setComment(notification.getDescription()).setReturnType(Types.VOID);
 606             }
 607         }
 608         listenerInterface.setDescription(createDescription(notifications, module.getName(), module.getModuleSourcePath()));
 609
 610         genCtx.get(module).addTopLevelNodeType(listenerInterface);
 611     }
 612
 613     /**
 614      * Converts all <b>identities</b> of the module to the list of
 615      * <code>Type</code> objects.
 616      *
 617      * @param module
 618      *            module from which is obtained set of all identity objects to
 619      *            iterate over them
 620      * @param context
 621      *            schema context only used as input parameter for method
 622      *            {@link identityToGenType}
 623      *
 624      */
 625     private void allIdentitiesToGenTypes(final Module module, final SchemaContext context) {
 626         final Set<IdentitySchemaNode> schemaIdentities = module.getIdentities();
 627         final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
 628
 629         if (schemaIdentities != null && !schemaIdentities.isEmpty()) {
 630             for (IdentitySchemaNode identity : schemaIdentities) {
 631                 identityToGenType(module, basePackageName, identity, context);
 632             }
 633         }
 634     }
 635
 636     /**
 637      * Converts the <b>identity</b> object to GeneratedType. Firstly it is
 638      * created transport object builder. If identity contains base identity then
 639      * reference to base identity is added to superior identity as its extend.
 640      * If identity doesn't contain base identity then only reference to abstract
 641      * class {@link org.opendaylight.yangtools.yang.model.api.BaseIdentity
 642      * BaseIdentity} is added
 643      *
 644      * @param module
 645      *            current module
 646      * @param basePackageName
 647      *            string contains the module package name
 648      * @param identity
 649      *            IdentitySchemaNode which contains data about identity
 650      * @param context
 651      *            SchemaContext which is used to get package and name
 652      *            information about base of identity
 653      *
 654      */
 655     private void identityToGenType(final Module module, final String basePackageName,
 656             final IdentitySchemaNode identity, final SchemaContext context) {
 657         if (identity == null) {
 658             return;
 659         }
 660         final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
 661         final String genTypeName = BindingMapping.getClassName(identity.getQName());
 662         final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName, genTypeName);
 663         final IdentitySchemaNode baseIdentity = identity.getBaseIdentity();
 664         if (baseIdentity == null) {
 665             final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
 666                     BaseIdentity.class.getSimpleName());
 667             newType.setExtendsType(gto.toInstance());
 668         } else {
 669             final Module baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);
 670             final String returnTypePkgName = BindingMapping.getRootPackageName(baseIdentityParentModule
 671                     .getQNameModule());
 672             final String returnTypeName = BindingMapping.getClassName(baseIdentity.getQName());
 673             final GeneratedTransferObject gto = new GeneratedTOBuilderImpl(returnTypePkgName, returnTypeName)
 674             .toInstance();
 675             newType.setExtendsType(gto);
 676         }
 677         newType.setAbstract(true);
 678         newType.addComment(identity.getDescription());
 679         newType.setDescription(createDescription(identity, newType.getFullyQualifiedName()));
 680         newType.setReference(identity.getReference());
 681         newType.setModuleName(module.getName());
 682         newType.setSchemaPath(identity.getPath().getPathFromRoot());
 683
 684         final QName qname = identity.getQName();
 685         qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, qname);
 686
 687         genCtx.get(module).addIdentityType(identity.getQName(), newType);
 688     }
 689
 690     private static Constant qnameConstant(final GeneratedTypeBuilderBase<?> toBuilder, final String constantName,
 691             final QName name) {
 692         StringBuilder sb = new StringBuilder("org.opendaylight.yangtools.yang.common.QName");
 693         sb.append(".create(");
 694         sb.append('"');
 695         sb.append(name.getNamespace());
 696         sb.append("\",\"");
 697         sb.append(name.getFormattedRevision());
 698         sb.append("\",\"");
 699         sb.append(name.getLocalName());
 700         sb.append("\");");
 701
 702         return toBuilder.addConstant(typeForClass(QName.class), constantName, sb.toString());
 703     }
 704
 705     /**
 706      * Converts all <b>groupings</b> of the module to the list of
 707      * <code>Type</code> objects. Firstly are groupings sorted according mutual
 708      * dependencies. At least dependent (independent) groupings are in the list
 709      * saved at first positions. For every grouping the record is added to map
 710      * {@link BindingGeneratorImpl#allGroupings allGroupings}
 711      *
 712      * @param module
 713      *            current module
 714      * @param collection
 715      *            of groupings from which types will be generated
 716      *
 717      */
 718     private void groupingsToGenTypes(final Module module, final Collection<GroupingDefinition> groupings) {
 719         final String basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
 720         final List<GroupingDefinition> groupingsSortedByDependencies = new GroupingDefinitionDependencySort()
 721         .sort(groupings);
 722         for (GroupingDefinition grouping : groupingsSortedByDependencies) {
 723             groupingToGenType(basePackageName, grouping, module);
 724         }
 725     }
 726
 727     /**
 728      * Converts individual grouping to GeneratedType. Firstly generated type
 729      * builder is created and every child node of grouping is resolved to the
 730      * method.
 731      *
 732      * @param basePackageName
 733      *            string contains the module package name
 734      * @param grouping
 735      *            GroupingDefinition which contains data about grouping
 736      * @param module
 737      *            current module
 738      * @return GeneratedType which is generated from grouping (object of type
 739      *         <code>GroupingDefinition</code>)
 740      */
 741     private void groupingToGenType(final String basePackageName, final GroupingDefinition grouping, final Module module) {
 742         final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath());
 743         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(packageName, grouping, module);
 744         genCtx.get(module).addGroupingType(grouping.getPath(), genType);
 745         resolveDataSchemaNodes(module, basePackageName, genType, genType, grouping.getChildNodes());
 746         groupingsToGenTypes(module, grouping.getGroupings());
 747         processUsesAugments(grouping, module);
 748     }
 749
 750     /**
 751      * Adds enumeration builder created from <code>enumTypeDef</code> to
 752      * <code>typeBuilder</code>.
 753      *
 754      * Each <code>enumTypeDef</code> item is added to builder with its name and
 755      * value.
 756      *
 757      * @param enumTypeDef
 758      *            EnumTypeDefinition contains enum data
 759      * @param enumName
 760      *            string contains name which will be assigned to enumeration
 761      *            builder
 762      * @param typeBuilder
 763      *            GeneratedTypeBuilder to which will be enum builder assigned
 764      * @return enumeration builder which contains data from
 765      *         <code>enumTypeDef</code>
 766      */
 767     private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName,
 768             final GeneratedTypeBuilder typeBuilder) {
 769         if ((enumTypeDef != null) && (typeBuilder != null) && (enumTypeDef.getQName() != null)
 770                 && (enumTypeDef.getQName().getLocalName() != null)) {
 771             final String enumerationName = BindingMapping.getClassName(enumName);
 772             final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);
 773             enumBuilder.setDescription(enumTypeDef.getDescription());
 774             enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
 775             return enumBuilder;
 776         }
 777         return null;
 778     }
 779
 780     /**
 781      * Generates type builder for <code>module</code>.
 782      *
 783      * @param module
 784      *            Module which is source of package name for generated type
 785      *            builder
 786      * @param postfix
 787      *            string which is added to the module class name representation
 788      *            as suffix
 789      * @return instance of GeneratedTypeBuilder which represents
 790      *         <code>module</code>.
 791      * @throws IllegalArgumentException
 792      *             if <code>module</code> is null
 793      */
 794     private GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix) {
 795         checkArgument(module != null, "Module reference cannot be NULL.");
 796         final String packageName = BindingMapping.getRootPackageName(module.getQNameModule());
 797         final String moduleName = BindingMapping.getClassName(module.getName()) + postfix;
 798
 799         final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName);
 800         moduleBuilder.setDescription(createDescription(module));
 801         moduleBuilder.setReference(module.getReference());
 802         moduleBuilder.setModuleName(moduleName);
 803
 804         return moduleBuilder;
 805     }
 806
 807     /**
 808      * Converts <code>augSchema</code> to list of <code>Type</code> which
 809      * contains generated type for augmentation. In addition there are also
 810      * generated types for all containers, list and choices which are child of
 811      * <code>augSchema</code> node or a generated types for cases are added if
 812      * augmented node is choice.
 813      *
 814      * @param augmentPackageName
 815      *            string with the name of the package to which the augmentation
 816      *            belongs
 817      * @param augSchema
 818      *            AugmentationSchema which is contains data about augmentation
 819      *            (target path, childs...)
 820      * @param module
 821      *            current module
 822      * @param parentUsesNode
 823      * @throws IllegalArgumentException
 824      *             <ul>
 825      *             <li>if <code>augmentPackageName</code> equals null</li>
 826      *             <li>if <code>augSchema</code> equals null</li>
 827      *             </ul>
 828      * @throws IllegalStateException
 829      *             if augment target path is null
 830      */
 831     private void augmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema,
 832             final Module module) {
 833         checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
 834         checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
 835         checkState(augSchema.getTargetPath() != null,
 836                 "Augmentation Schema does not contain Target Path (Target Path is NULL).");
 837
 838         processUsesAugments(augSchema, module);
 839         final SchemaPath targetPath = augSchema.getTargetPath();
 840         SchemaNode targetSchemaNode = null;
 841
 842         targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
 843         if (targetSchemaNode instanceof DataSchemaNode && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
 844             if (targetSchemaNode instanceof DerivableSchemaNode) {
 845                 targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orNull();
 846             }
 847             if (targetSchemaNode == null) {
 848                 throw new IllegalStateException("Failed to find target node from grouping in augmentation " + augSchema
 849                         + " in module " + module.getName());
 850             }
 851         }
 852         if (targetSchemaNode == null) {
 853             throw new IllegalArgumentException("augment target not found: " + targetPath);
 854         }
 855
 856         GeneratedTypeBuilder targetTypeBuilder = findChildNodeByPath(targetSchemaNode.getPath());
 857         if (targetTypeBuilder == null) {
 858             targetTypeBuilder = findCaseByPath(targetSchemaNode.getPath());
 859         }
 860         if (targetTypeBuilder == null) {
 861             throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
 862         }
 863
 864         if (!(targetSchemaNode instanceof ChoiceNode)) {
 865             String packageName = augmentPackageName;
 866             final Type targetType = new ReferencedTypeImpl(targetTypeBuilder.getPackageName(),
 867                     targetTypeBuilder.getName());
 868             addRawAugmentGenTypeDefinition(module, packageName, augmentPackageName, targetType, augSchema);
 869
 870         } else {
 871             generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.toInstance(),
 872                     (ChoiceNode) targetSchemaNode, augSchema.getChildNodes());
 873         }
 874     }
 875
 876     private void usesAugmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema,
 877             final Module module, final UsesNode usesNode, final DataNodeContainer usesNodeParent) {
 878         checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
 879         checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
 880         checkState(augSchema.getTargetPath() != null,
 881                 "Augmentation Schema does not contain Target Path (Target Path is NULL).");
 882
 883         processUsesAugments(augSchema, module);
 884         final SchemaPath targetPath = augSchema.getTargetPath();
 885         SchemaNode targetSchemaNode = findOriginalTargetFromGrouping(targetPath, usesNode);
 886         if (targetSchemaNode == null) {
 887             throw new IllegalArgumentException("augment target not found: " + targetPath);
 888         }
 889
 890         GeneratedTypeBuilder targetTypeBuilder = findChildNodeByPath(targetSchemaNode.getPath());
 891         if (targetTypeBuilder == null) {
 892             targetTypeBuilder = findCaseByPath(targetSchemaNode.getPath());
 893         }
 894         if (targetTypeBuilder == null) {
 895             throw new NullPointerException("Target type not yet generated: " + targetSchemaNode);
 896         }
 897         targetTypeBuilder.setSuitableForBoxing(false);
 898
 899         if (!(targetSchemaNode instanceof ChoiceNode)) {
 900             String packageName = augmentPackageName;
 901             if (usesNodeParent instanceof SchemaNode) {
 902                 packageName = packageNameForGeneratedType(augmentPackageName, ((SchemaNode) usesNodeParent).getPath(),
 903                         true);
 904             }
 905             addRawAugmentGenTypeDefinition(module, packageName, augmentPackageName, targetTypeBuilder.toInstance(),
 906                     augSchema);
 907         } else {
 908             generateTypesFromAugmentedChoiceCases(module, augmentPackageName, targetTypeBuilder.toInstance(),
 909                     (ChoiceNode) targetSchemaNode, augSchema.getChildNodes());
 910         }
 911     }
 912
 913     /**
 914      * Convenient method to find node added by uses statement.
 915      *
 916      * @param targetPath
 917      *            node path
 918      * @param parentUsesNode
 919      *            parent of uses node
 920      * @return node from its original location in grouping
 921      */
 922     private DataSchemaNode findOriginalTargetFromGrouping(final SchemaPath targetPath, final UsesNode parentUsesNode) {
 923         SchemaNode targetGrouping = findNodeInSchemaContext(schemaContext, parentUsesNode.getGroupingPath()
 924                 .getPathFromRoot());
 925         if (!(targetGrouping instanceof GroupingDefinition)) {
 926             throw new IllegalArgumentException("Failed to generate code for augment in " + parentUsesNode);
 927         }
 928
 929         GroupingDefinition grouping = (GroupingDefinition) targetGrouping;
 930         SchemaNode result = grouping;
 931         for (QName node : targetPath.getPathFromRoot()) {
 932             // finding by local name is valid, grouping cannot contain nodes
 933             // with same name and different namespace
 934             if (result instanceof DataNodeContainer) {
 935                 result = ((DataNodeContainer) result).getDataChildByName(node.getLocalName());
 936             } else if (result instanceof ChoiceNode) {
 937                 result = ((ChoiceNode) result).getCaseNodeByName(node.getLocalName());
 938             }
 939         }
 940         if (result == null) {
 941             return null;
 942         }
 943
 944         boolean fromUses = ((DataSchemaNode) result).isAddedByUses();
 945         Iterator<UsesNode> groupingUses = grouping.getUses().iterator();
 946         while (groupingUses.hasNext() && fromUses) {
 947             result = findOriginalTargetFromGrouping(targetPath, groupingUses.next());
 948             if (result != null) {
 949                 fromUses = ((DataSchemaNode) result).isAddedByUses();
 950             }
 951         }
 952         if (fromUses) {
 953             // this indicates invalid yang and thus possible bug in code because
 954             // invalid yang should be already spotted by parser
 955             throw new IllegalStateException("Failed to generate code for augment in " + parentUsesNode);
 956         }
 957
 958         return (DataSchemaNode) result;
 959     }
 960
 961     /**
 962      * Returns a generated type builder for an augmentation.
 963      *
 964      * The name of the type builder is equal to the name of augmented node with
 965      * serial number as suffix.
 966      *
 967      * @param module
 968      *            current module
 969      * @param augmentPackageName
 970      *            string with contains the package name to which the augment
 971      *            belongs
 972      * @param basePackageName
 973      *            string with the package name to which the augmented node
 974      *            belongs
 975      * @param targetTypeRef
 976      *            target type
 977      * @param augSchema
 978      *            augmentation schema which contains data about the child nodes
 979      *            and uses of augment
 980      * @return generated type builder for augment
 981      */
 982     private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final Module module, final String augmentPackageName,
 983             final String basePackageName, final Type targetTypeRef, final AugmentationSchema augSchema) {
 984         Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);
 985         if (augmentBuilders == null) {
 986             augmentBuilders = new HashMap<>();
 987             genTypeBuilders.put(augmentPackageName, augmentBuilders);
 988         }
 989         final String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());
 990
 991         String augTypeName;
 992         if (augIdentifier != null) {
 993             augTypeName = BindingMapping.getClassName(augIdentifier);
 994         } else {
 995             augTypeName = augGenTypeName(augmentBuilders, targetTypeRef.getName());
 996         }
 997
 998         final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);
 999
1000         augTypeBuilder.addImplementsType(DATA_OBJECT);
1001         augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));
1002         addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
1003
1004         augSchemaNodeToMethods(module, basePackageName, augTypeBuilder, augTypeBuilder, augSchema.getChildNodes());
1005         augmentBuilders.put(augTypeName, augTypeBuilder);
1006
1007         if(!augSchema.getChildNodes().isEmpty()) {
1008             genCtx.get(module).addTargetToAugmentation(targetTypeRef, augTypeBuilder);
1009             genCtx.get(module).addTypeToAugmentation(augTypeBuilder, augSchema);
1010
1011         }
1012         genCtx.get(module).addAugmentType(augTypeBuilder);
1013         return augTypeBuilder;
1014     }
1015
1016     /**
1017      *
1018      * @param unknownSchemaNodes
1019      * @return nodeParameter of UnknownSchemaNode
1020      */
1021     private String getAugmentIdentifier(final List<UnknownSchemaNode> unknownSchemaNodes) {
1022         for (UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {
1023             final QName nodeType = unknownSchemaNode.getNodeType();
1024             if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName())
1025                     && YANG_EXT_NAMESPACE.equals(nodeType.getNamespace().toString())) {
1026                 return unknownSchemaNode.getNodeParameter();
1027             }
1028         }
1029         return null;
1030     }
1031
1032     /**
1033      * Returns first unique name for the augment generated type builder. The
1034      * generated type builder name for augment consists from name of augmented
1035      * node and serial number of its augmentation.
1036      *
1037      * @param builders
1038      *            map of builders which were created in the package to which the
1039      *            augmentation belongs
1040      * @param genTypeName
1041      *            string with name of augmented node
1042      * @return string with unique name for augmentation builder
1043      */
1044     private String augGenTypeName(final Map<String, GeneratedTypeBuilder> builders, final String genTypeName) {
1045         int index = 1;
1046         if (builders != null) {
1047             while (builders.containsKey(genTypeName + index)) {
1048                 index = index + 1;
1049             }
1050         }
1051         return genTypeName + index;
1052     }
1053
1054     /**
1055      * Adds the methods to <code>typeBuilder</code> which represent subnodes of
1056      * node for which <code>typeBuilder</code> was created.
1057      *
1058      * The subnodes aren't mapped to the methods if they are part of grouping or
1059      * augment (in this case are already part of them).
1060      *
1061      * @param module
1062      *            current module
1063      * @param basePackageName
1064      *            string contains the module package name
1065      * @param parent
1066      *            generated type builder which represents any node. The subnodes
1067      *            of this node are added to the <code>typeBuilder</code> as
1068      *            methods. The subnode can be of type leaf, leaf-list, list,
1069      *            container, choice.
1070      * @param childOf
1071      *            parent type
1072      * @param schemaNodes
1073      *            set of data schema nodes which are the children of the node
1074      *            for which <code>typeBuilder</code> was created
1075      * @return generated type builder which is the same builder as input
1076      *         parameter. The getter methods (representing child nodes) could be
1077      *         added to it.
1078      */
1079     private GeneratedTypeBuilder resolveDataSchemaNodes(final Module module, final String basePackageName,
1080             final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final Iterable<DataSchemaNode> schemaNodes) {
1081         if (schemaNodes != null && parent != null) {
1082             for (DataSchemaNode schemaNode : schemaNodes) {
1083                 if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {
1084                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, parent, childOf, module);
1085                 }
1086             }
1087         }
1088         return parent;
1089     }
1090
1091     /**
1092      * Adds the methods to <code>typeBuilder</code> what represents subnodes of
1093      * node for which <code>typeBuilder</code> was created.
1094      *
1095      * @param module
1096      *            current module
1097      * @param basePackageName
1098      *            string contains the module package name
1099      * @param typeBuilder
1100      *            generated type builder which represents any node. The subnodes
1101      *            of this node are added to the <code>typeBuilder</code> as
1102      *            methods. The subnode can be of type leaf, leaf-list, list,
1103      *            container, choice.
1104      * @param childOf
1105      *            parent type
1106      * @param schemaNodes
1107      *            set of data schema nodes which are the children of the node
1108      *            for which <code>typeBuilder</code> was created
1109      * @return generated type builder which is the same object as the input
1110      *         parameter <code>typeBuilder</code>. The getter method could be
1111      *         added to it.
1112      */
1113     private GeneratedTypeBuilder augSchemaNodeToMethods(final Module module, final String basePackageName,
1114             final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf,
1115             final Iterable<DataSchemaNode> schemaNodes) {
1116         if ((schemaNodes != null) && (typeBuilder != null)) {
1117             for (DataSchemaNode schemaNode : schemaNodes) {
1118                 if (!schemaNode.isAugmenting()) {
1119                     addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder, childOf, module);
1120                 }
1121             }
1122         }
1123         return typeBuilder;
1124     }
1125
1126     /**
1127      * Adds to <code>typeBuilder</code> a method which is derived from
1128      * <code>schemaNode</code>.
1129      *
1130      * @param basePackageName
1131      *            string with the module package name
1132      * @param node
1133      *            data schema node which is added to <code>typeBuilder</code> as
1134      *            a method
1135      * @param typeBuilder
1136      *            generated type builder to which is <code>schemaNode</code>
1137      *            added as a method.
1138      * @param childOf
1139      *            parent type
1140      * @param module
1141      *            current module
1142      */
1143     private void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode node,
1144             final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Module module) {
1145         if (node != null && typeBuilder != null) {
1146             if (node instanceof LeafSchemaNode) {
1147                 resolveLeafSchemaNodeAsMethod(typeBuilder, (LeafSchemaNode) node);
1148             } else if (node instanceof LeafListSchemaNode) {
1149                 resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) node);
1150             } else if (node instanceof ContainerSchemaNode) {
1151                 containerToGenType(module, basePackageName, typeBuilder, childOf, (ContainerSchemaNode) node);
1152             } else if (node instanceof ListSchemaNode) {
1153                 listToGenType(module, basePackageName, typeBuilder, childOf, (ListSchemaNode) node);
1154             } else if (node instanceof ChoiceNode) {
1155                 choiceToGeneratedType(module, basePackageName, typeBuilder, (ChoiceNode) node);
1156             } else {
1157                 // TODO: anyxml not yet supported
1158                 LOG.debug("Unable to add schema node {} as method in {}: unsupported type of node.", node.getClass(),
1159                         typeBuilder.getFullyQualifiedName());
1160             }
1161         }
1162     }
1163
1164     /**
1165      * Converts <code>choiceNode</code> to the list of generated types for
1166      * choice and its cases.
1167      *
1168      * The package names for choice and for its cases are created as
1169      * concatenation of the module package (<code>basePackageName</code>) and
1170      * names of all parents node.
1171      *
1172      * @param module
1173      *            current module
1174      * @param basePackageName
1175      *            string with the module package name
1176      * @param parent
1177      *            parent type
1178      * @param choiceNode
1179      *            choice node which is mapped to generated type. Also child
1180      *            nodes - cases are mapped to generated types.
1181      * @throws IllegalArgumentException
1182      *             <ul>
1183      *             <li>if <code>basePackageName</code> is null</li>
1184      *             <li>if <code>choiceNode</code> is null</li>
1185      *             </ul>
1186      */
1187     private void choiceToGeneratedType(final Module module, final String basePackageName,
1188             final GeneratedTypeBuilder parent, final ChoiceNode choiceNode) {
1189         checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
1190         checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
1191
1192         if (!choiceNode.isAddedByUses()) {
1193             final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());
1194             final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);
1195             constructGetter(parent, choiceNode.getQName().getLocalName(), choiceNode.getDescription(),
1196                     choiceTypeBuilder);
1197             choiceTypeBuilder.addImplementsType(typeForClass(DataContainer.class));
1198             choiceTypeBuilder.setParentType(parent);
1199             genCtx.get(module).addChildNodeType(choiceNode, choiceTypeBuilder);
1200             generateTypesFromChoiceCases(module, basePackageName, choiceTypeBuilder.toInstance(), choiceNode);
1201         }
1202     }
1203
1204     /**
1205      * Converts <code>caseNodes</code> set to list of corresponding generated
1206      * types.
1207      *
1208      * For every <i>case</i> which isn't added through augment or <i>uses</i> is
1209      * created generated type builder. The package names for the builder is
1210      * created as concatenation of the module package (
1211      * <code>basePackageName</code>) and names of all parents nodes of the
1212      * concrete <i>case</i>. There is also relation "<i>implements type</i>"
1213      * between every case builder and <i>choice</i> type
1214      *
1215      * @param module
1216      *            current module
1217      * @param basePackageName
1218      *            string with the module package name
1219      * @param refChoiceType
1220      *            type which represents superior <i>case</i>
1221      * @param choiceNode
1222      *            choice case node which is mapped to generated type
1223      * @return list of generated types for <code>caseNodes</code>.
1224      * @throws IllegalArgumentException
1225      *             <ul>
1226      *             <li>if <code>basePackageName</code> equals null</li>
1227      *             <li>if <code>refChoiceType</code> equals null</li>
1228      *             <li>if <code>caseNodes</code> equals null</li>
1229      *             </ul>
1230      */
1231     private void generateTypesFromChoiceCases(final Module module, final String basePackageName,
1232             final Type refChoiceType, final ChoiceNode choiceNode) {
1233         checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
1234         checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
1235         checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
1236
1237         final Set<ChoiceCaseNode> caseNodes = choiceNode.getCases();
1238         if (caseNodes == null) {
1239             return;
1240         }
1241
1242         for (ChoiceCaseNode caseNode : caseNodes) {
1243             if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
1244                 final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
1245                 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode, module);
1246                 caseTypeBuilder.addImplementsType(refChoiceType);
1247                 genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
1248                 genCtx.get(module).addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
1249                 final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
1250                 if (caseChildNodes != null) {
1251                     Object parentNode = null;
1252                     final SchemaPath nodeSp = choiceNode.getPath();
1253                     parentNode = findDataSchemaNode(schemaContext, nodeSp.getParent());
1254
1255                     SchemaNode parent;
1256                     if (parentNode instanceof AugmentationSchema) {
1257                         final AugmentationSchema augSchema = (AugmentationSchema) parentNode;
1258                         final SchemaPath targetPath = augSchema.getTargetPath();
1259                         SchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);
1260                         if (targetSchemaNode instanceof DataSchemaNode
1261                                 && ((DataSchemaNode) targetSchemaNode).isAddedByUses()) {
1262                             if (targetSchemaNode instanceof DerivableSchemaNode) {
1263                                 targetSchemaNode = ((DerivableSchemaNode) targetSchemaNode).getOriginal().orNull();
1264                             }
1265                             if (targetSchemaNode == null) {
1266                                 throw new IllegalStateException(
1267                                         "Failed to find target node from grouping for augmentation " + augSchema
1268                                         + " in module " + module.getName());
1269                             }
1270                         }
1271                         parent = targetSchemaNode;
1272                     } else {
1273                         final SchemaPath sp = choiceNode.getPath();
1274                         parent = findDataSchemaNode(schemaContext, sp.getParent());
1275                     }
1276                     GeneratedTypeBuilder childOfType = findChildNodeByPath(parent.getPath());
1277                     if (childOfType == null) {
1278                         childOfType = findGroupingByPath(parent.getPath());
1279                     }
1280                     resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, caseChildNodes);
1281                 }
1282             }
1283
1284             processUsesAugments(caseNode, module);
1285         }
1286     }
1287
1288     /**
1289      * Generates list of generated types for all the cases of a choice which are
1290      * added to the choice through the augment.
1291      *
1292      * @param module
1293      *            current module
1294      * @param basePackageName
1295      *            string contains name of package to which augment belongs. If
1296      *            an augmented choice is from an other package (pcg1) than an
1297      *            augmenting choice (pcg2) then case's of the augmenting choice
1298      *            will belong to pcg2.
1299      * @param targetType
1300      *            Type which represents target choice
1301      * @param targetNode
1302      *            node which represents target choice
1303      * @param augmentedNodes
1304      *            set of choice case nodes for which is checked if are/aren't
1305      *            added to choice through augmentation
1306      * @return list of generated types which represents augmented cases of
1307      *         choice <code>refChoiceType</code>
1308      * @throws IllegalArgumentException
1309      *             <ul>
1310      *             <li>if <code>basePackageName</code> is null</li>
1311      *             <li>if <code>targetType</code> is null</li>
1312      *             <li>if <code>augmentedNodes</code> is null</li>
1313      *             </ul>
1314      */
1315     private void generateTypesFromAugmentedChoiceCases(final Module module, final String basePackageName,
1316             final Type targetType, final ChoiceNode targetNode, final Iterable<DataSchemaNode> augmentedNodes) {
1317         checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
1318         checkArgument(targetType != null, "Referenced Choice Type cannot be NULL.");
1319         checkArgument(augmentedNodes != null, "Set of Choice Case Nodes cannot be NULL.");
1320
1321         for (DataSchemaNode caseNode : augmentedNodes) {
1322             if (caseNode != null) {
1323                 final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());
1324                 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode, module);
1325                 caseTypeBuilder.addImplementsType(targetType);
1326
1327                 SchemaNode parent = null;
1328                 final SchemaPath nodeSp = targetNode.getPath();
1329                 parent = findDataSchemaNode(schemaContext, nodeSp.getParent());
1330
1331                 GeneratedTypeBuilder childOfType = null;
1332                 if (parent instanceof Module) {
1333                     childOfType = genCtx.get(parent).getModuleNode();
1334                 } else if (parent instanceof ChoiceCaseNode) {
1335                     childOfType = findCaseByPath(parent.getPath());
1336                 } else if (parent instanceof DataSchemaNode || parent instanceof NotificationDefinition) {
1337                     childOfType = findChildNodeByPath(parent.getPath());
1338                 } else if (parent instanceof GroupingDefinition) {
1339                     childOfType = findGroupingByPath(parent.getPath());
1340                 }
1341
1342                 if (childOfType == null) {
1343                     throw new IllegalArgumentException("Failed to find parent type of choice " + targetNode);
1344                 }
1345
1346                 ChoiceCaseNode node = null;
1347                 if (caseNode instanceof ChoiceCaseNode) {
1348                     node = (ChoiceCaseNode) caseNode;
1349                 } else {
1350                     node = targetNode.getCaseNodeByName(caseNode.getQName().getLocalName());
1351                 }
1352                 final Iterable<DataSchemaNode> childNodes = node.getChildNodes();
1353                 if (childNodes != null) {
1354                     resolveDataSchemaNodes(module, basePackageName, caseTypeBuilder, childOfType, childNodes);
1355                 }
1356                 genCtx.get(module).addCaseType(caseNode.getPath(), caseTypeBuilder);
1357                 genCtx.get(module).addChoiceToCaseMapping(targetType, caseTypeBuilder, node);
1358             }
1359         }
1360     }
1361
1362     /**
1363      * Converts <code>leaf</code> to the getter method which is added to
1364      * <code>typeBuilder</code>.
1365      *
1366      * @param typeBuilder
1367      *            generated type builder to which is added getter method as
1368      *            <code>leaf</code> mapping
1369      * @param leaf
1370      *            leaf schema node which is mapped as getter method which is
1371      *            added to <code>typeBuilder</code>
1372      * @return boolean value
1373      *         <ul>
1374      *         <li>false - if <code>leaf</code> or <code>typeBuilder</code> are
1375      *         null</li>
1376      *         <li>true - in other cases</li>
1377      *         </ul>
1378      */
1379     private Type resolveLeafSchemaNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) {
1380         Type returnType = null;
1381         if ((leaf != null) && (typeBuilder != null)) {
1382             final String leafName = leaf.getQName().getLocalName();
1383             String leafDesc = leaf.getDescription();
1384             if (leafDesc == null) {
1385                 leafDesc = "";
1386             }
1387
1388             final Module parentModule = findParentModule(schemaContext, leaf);
1389             if (leafName != null && !leaf.isAddedByUses()) {
1390                 final TypeDefinition<?> typeDef = leaf.getType();
1391
1392                 GeneratedTOBuilder genTOBuilder;
1393                 if (typeDef instanceof EnumTypeDefinition) {
1394                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
1395                     final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
1396                     final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(),
1397                             typeBuilder);
1398
1399                     if (enumBuilder != null) {
1400                         returnType = enumBuilder.toInstance(typeBuilder);
1401                     }
1402                     ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
1403                 } else if (typeDef instanceof UnionType) {
1404                     genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
1405                     if (genTOBuilder != null) {
1406                         returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
1407                     }
1408                 } else if (typeDef instanceof BitsTypeDefinition) {
1409                     genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
1410                     if (genTOBuilder != null) {
1411                         returnType = genTOBuilder.toInstance();
1412                     }
1413                 } else {
1414                     final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
1415                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, restrictions);
1416                 }
1417                 if (returnType != null) {
1418                     final MethodSignatureBuilder getter = constructGetter(typeBuilder, leafName, leafDesc, returnType);
1419                     processContextRefExtension(leaf, getter, parentModule);
1420                 }
1421             }
1422         }
1423         return returnType;
1424     }
1425
1426     private void processContextRefExtension(final LeafSchemaNode leaf, final MethodSignatureBuilder getter,
1427             final Module module) {
1428         for (UnknownSchemaNode node : leaf.getUnknownSchemaNodes()) {
1429             final QName nodeType = node.getNodeType();
1430             if ("context-reference".equals(nodeType.getLocalName())) {
1431                 final String nodeParam = node.getNodeParameter();
1432                 IdentitySchemaNode identity = null;
1433                 String basePackageName = null;
1434                 final Iterable<String> splittedElement = COLON_SPLITTER.split(nodeParam);
1435                 final Iterator<String> iterator = splittedElement.iterator();
1436                 final int length = Iterables.size(splittedElement);
1437                 if (length == 1) {
1438                     identity = findIdentityByName(module.getIdentities(), iterator.next());
1439                     basePackageName = BindingMapping.getRootPackageName(module.getQNameModule());
1440                 } else if (length == 2) {
1441                     String prefix = iterator.next();
1442                     final Module dependentModule = findModuleFromImports(module.getImports(), prefix);
1443                     if (dependentModule == null) {
1444                         throw new IllegalArgumentException("Failed to process context-reference: unknown prefix "
1445                                 + prefix);
1446                     }
1447                     identity = findIdentityByName(dependentModule.getIdentities(), iterator.next());
1448                     basePackageName = BindingMapping.getRootPackageName(dependentModule.getQNameModule());
1449                 } else {
1450                     throw new IllegalArgumentException("Failed to process context-reference: unknown identity "
1451                             + nodeParam);
1452                 }
1453                 if (identity == null) {
1454                     throw new IllegalArgumentException("Failed to process context-reference: unknown identity "
1455                             + nodeParam);
1456                 }
1457
1458                 final Class<RoutingContext> clazz = RoutingContext.class;
1459                 final AnnotationTypeBuilder rc = getter.addAnnotation(clazz.getPackage().getName(),
1460                         clazz.getSimpleName());
1461                 final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
1462                 final String genTypeName = BindingMapping.getClassName(identity.getQName().getLocalName());
1463                 rc.addParameter("value", packageName + "." + genTypeName + ".class");
1464             }
1465         }
1466     }
1467
1468     private IdentitySchemaNode findIdentityByName(final Set<IdentitySchemaNode> identities, final String name) {
1469         for (IdentitySchemaNode id : identities) {
1470             if (id.getQName().getLocalName().equals(name)) {
1471                 return id;
1472             }
1473         }
1474         return null;
1475     }
1476
1477     private Module findModuleFromImports(final Set<ModuleImport> imports, final String prefix) {
1478         for (ModuleImport imp : imports) {
1479             if (imp.getPrefix().equals(prefix)) {
1480                 return schemaContext.findModuleByName(imp.getModuleName(), imp.getRevision());
1481             }
1482         }
1483         return null;
1484     }
1485
1486     private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
1487             final boolean isReadOnly, final Module module) {
1488         if ((leaf != null) && (toBuilder != null)) {
1489             final String leafName = leaf.getQName().getLocalName();
1490             String leafDesc = leaf.getDescription();
1491             if (leafDesc == null) {
1492                 leafDesc = "";
1493             }
1494
1495             if (leafName != null) {
1496                 Type returnType = null;
1497                 final TypeDefinition<?> typeDef = leaf.getType();
1498                 if (typeDef instanceof UnionTypeDefinition) {
1499                     // GeneratedType for this type definition should be already
1500                     // created
1501                     QName qname = typeDef.getQName();
1502                     Module unionModule = schemaContext.findModuleByNamespaceAndRevision(qname.getNamespace(),
1503                             qname.getRevision());
1504                     final ModuleContext mc = genCtx.get(unionModule);
1505                     returnType = mc.getTypedefs().get(typeDef.getPath());
1506                 } else {
1507                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);
1508                 }
1509                 return resolveLeafSchemaNodeAsProperty(toBuilder, leaf, returnType, isReadOnly);
1510             }
1511         }
1512         return false;
1513     }
1514
1515     /**
1516      * Converts <code>leaf</code> schema node to property of generated TO
1517      * builder.
1518      *
1519      * @param toBuilder
1520      *            generated TO builder to which is <code>leaf</code> added as
1521      *            property
1522      * @param leaf
1523      *            leaf schema node which is added to <code>toBuilder</code> as
1524      *            property
1525      * @param returnType
1526      *            property type
1527      * @param isReadOnly
1528      *            boolean value which says if leaf property is|isn't read only
1529      * @return boolean value
1530      *         <ul>
1531      *         <li>false - if <code>leaf</code>, <code>toBuilder</code> or leaf
1532      *         name equals null or if leaf is added by <i>uses</i>.</li>
1533      *         <li>true - other cases</li>
1534      *         </ul>
1535      */
1536     private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
1537             final Type returnType, final boolean isReadOnly) {
1538         if (returnType == null) {
1539             return false;
1540         }
1541         final String leafName = leaf.getQName().getLocalName();
1542         final String leafDesc = leaf.getDescription();
1543         final GeneratedPropertyBuilder propBuilder = toBuilder.addProperty(parseToValidParamName(leafName));
1544         propBuilder.setReadOnly(isReadOnly);
1545         propBuilder.setReturnType(returnType);
1546         propBuilder.setComment(leafDesc);
1547         toBuilder.addEqualsIdentity(propBuilder);
1548         toBuilder.addHashIdentity(propBuilder);
1549         toBuilder.addToStringProperty(propBuilder);
1550         return true;
1551     }
1552
1553     /**
1554      * Converts <code>node</code> leaf list schema node to getter method of
1555      * <code>typeBuilder</code>.
1556      *
1557      * @param typeBuilder
1558      *            generated type builder to which is <code>node</code> added as
1559      *            getter method
1560      * @param node
1561      *            leaf list schema node which is added to
1562      *            <code>typeBuilder</code> as getter method
1563      * @return boolean value
1564      *         <ul>
1565      *         <li>true - if <code>node</code>, <code>typeBuilder</code>,
1566      *         nodeName equal null or <code>node</code> is added by <i>uses</i></li>
1567      *         <li>false - other cases</li>
1568      *         </ul>
1569      */
1570     private boolean resolveLeafListSchemaNode(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node) {
1571         if ((node != null) && (typeBuilder != null)) {
1572             final QName nodeName = node.getQName();
1573
1574             if (nodeName != null && !node.isAddedByUses()) {
1575                 final TypeDefinition<?> typeDef = node.getType();
1576                 final Module parentModule = findParentModule(schemaContext, node);
1577
1578                 Type returnType = null;
1579                 if (typeDef instanceof EnumTypeDefinition) {
1580                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node);
1581                     final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
1582                     final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName,
1583                             typeBuilder);
1584                     returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
1585                     ((TypeProviderImpl) typeProvider).putReferencedType(node.getPath(), returnType);
1586                 } else if (typeDef instanceof UnionType) {
1587                     final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
1588                     if (genTOBuilder != null) {
1589                         returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
1590                     }
1591                 } else if (typeDef instanceof BitsTypeDefinition) {
1592                     final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
1593                     returnType = genTOBuilder.toInstance();
1594                 } else {
1595                     final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
1596                     returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, restrictions);
1597                 }
1598
1599                 final ParameterizedType listType = Types.listTypeFor(returnType);
1600                 constructGetter(typeBuilder, nodeName.getLocalName(), node.getDescription(), listType);
1601                 return true;
1602             }
1603         }
1604         return false;
1605     }
1606
1607     private Type createReturnTypeForUnion(final GeneratedTOBuilder genTOBuilder, final TypeDefinition<?> typeDef,
1608             final GeneratedTypeBuilder typeBuilder, final Module parentModule) {
1609         final GeneratedTOBuilderImpl returnType = new GeneratedTOBuilderImpl(genTOBuilder.getPackageName(),
1610                 genTOBuilder.getName());
1611
1612         returnType.setDescription(typeDef.getDescription());
1613         returnType.setReference(typeDef.getReference());
1614         returnType.setSchemaPath(typeDef.getPath().getPathFromRoot());
1615         returnType.setModuleName(parentModule.getName());
1616
1617         genTOBuilder.setTypedef(true);
1618         genTOBuilder.setIsUnion(true);
1619         ((TypeProviderImpl) typeProvider).addUnitsToGenTO(genTOBuilder, typeDef.getUnits());
1620
1621         // union builder
1622         final GeneratedTOBuilder unionBuilder = new GeneratedTOBuilderImpl(typeBuilder.getPackageName(),
1623                 genTOBuilder.getName() + "Builder");
1624         unionBuilder.setIsUnionBuilder(true);
1625         final MethodSignatureBuilder method = unionBuilder.addMethod("getDefaultInstance");
1626         method.setReturnType(returnType);
1627         method.addParameter(Types.STRING, "defaultValue");
1628         method.setAccessModifier(AccessModifier.PUBLIC);
1629         method.setStatic(true);
1630
1631         final Set<Type> types = ((TypeProviderImpl) typeProvider).getAdditionalTypes().get(parentModule);
1632         if (types == null) {
1633             ((TypeProviderImpl) typeProvider).getAdditionalTypes().put(parentModule,
1634                     Sets.<Type> newHashSet(unionBuilder.toInstance()));
1635         } else {
1636             types.add(unionBuilder.toInstance());
1637         }
1638         return returnType.toInstance();
1639     }
1640
1641     private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
1642             final Module module) {
1643         return addDefaultInterfaceDefinition(packageName, schemaNode, null, module);
1644     }
1645
1646     /**
1647      * Instantiates generated type builder with <code>packageName</code> and
1648      * <code>schemaNode</code>.
1649      *
1650      * The new builder always implements
1651      * {@link org.opendaylight.yangtools.yang.binding.DataObject DataObject}.<br />
1652      * If <code>schemaNode</code> is instance of GroupingDefinition it also
1653      * implements {@link org.opendaylight.yangtools.yang.binding.Augmentable
1654      * Augmentable}.<br />
1655      * If <code>schemaNode</code> is instance of
1656      * {@link org.opendaylight.yangtools.yang.model.api.DataNodeContainer
1657      * DataNodeContainer} it can also implement nodes which are specified in
1658      * <i>uses</i>.
1659      *
1660      * @param packageName
1661      *            string with the name of the package to which
1662      *            <code>schemaNode</code> belongs.
1663      * @param schemaNode
1664      *            schema node for which is created generated type builder
1665      * @param parent
1666      *            parent type (can be null)
1667      * @return generated type builder <code>schemaNode</code>
1668      */
1669     private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
1670             final Type parent, final Module module) {
1671         final GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, "");
1672         if (parent == null) {
1673             it.addImplementsType(DATA_OBJECT);
1674         } else {
1675             it.addImplementsType(BindingTypes.childOf(parent));
1676         }
1677         if (!(schemaNode instanceof GroupingDefinition)) {
1678             it.addImplementsType(augmentable(it));
1679         }
1680
1681         if (schemaNode instanceof DataNodeContainer) {
1682             groupingsToGenTypes(module, ((DataNodeContainer) schemaNode).getGroupings());
1683             addImplementedInterfaceFromUses((DataNodeContainer) schemaNode, it);
1684         }
1685
1686         return it;
1687     }
1688
1689     /**
1690      * Wraps the calling of the same overloaded method.
1691      *
1692      * @param packageName
1693      *            string with the package name to which returning generated type
1694      *            builder belongs
1695      * @param schemaNode
1696      *            schema node which provide data about the schema node name
1697      * @return generated type builder for <code>schemaNode</code>
1698      */
1699     private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {
1700         return addRawInterfaceDefinition(packageName, schemaNode, "");
1701     }
1702
1703     /**
1704      * Returns reference to generated type builder for specified
1705      * <code>schemaNode</code> with <code>packageName</code>.
1706      *
1707      * Firstly the generated type builder is searched in
1708      * {@link BindingGeneratorImpl#genTypeBuilders genTypeBuilders}. If it isn't
1709      * found it is created and added to <code>genTypeBuilders</code>.
1710      *
1711      * @param packageName
1712      *            string with the package name to which returning generated type
1713      *            builder belongs
1714      * @param schemaNode
1715      *            schema node which provide data about the schema node name
1716      * @param prefix
1717      *            return type name prefix
1718      * @return generated type builder for <code>schemaNode</code>
1719      * @throws IllegalArgumentException
1720      *             <ul>
1721      *             <li>if <code>schemaNode</code> is null</li>
1722      *             <li>if <code>packageName</code> is null</li>
1723      *             <li>if QName of schema node is null</li>
1724      *             <li>if schemaNode name is null</li>
1725      *             </ul>
1726      *
1727      */
1728     private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
1729             final String prefix) {
1730         checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
1731         checkArgument(packageName != null, "Package Name for Generated Type cannot be NULL.");
1732         checkArgument(schemaNode.getQName() != null, "QName for Data Schema Node cannot be NULL.");
1733         final String schemaNodeName = schemaNode.getQName().getLocalName();
1734         checkArgument(schemaNodeName != null, "Local Name of QName for Data Schema Node cannot be NULL.");
1735
1736         String genTypeName;
1737         if (prefix == null) {
1738             genTypeName = BindingMapping.getClassName(schemaNodeName);
1739         } else {
1740             genTypeName = prefix + BindingMapping.getClassName(schemaNodeName);
1741         }
1742
1743         // FIXME: Validation of name conflict
1744         final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);
1745         final Module module = findParentModule(schemaContext, schemaNode);
1746         qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
1747         newType.addComment(schemaNode.getDescription());
1748         newType.setDescription(createDescription(schemaNode, newType.getFullyQualifiedName()));
1749         newType.setReference(schemaNode.getReference());
1750         newType.setSchemaPath(schemaNode.getPath().getPathFromRoot());
1751         newType.setModuleName(module.getName());
1752
1753         if (!genTypeBuilders.containsKey(packageName)) {
1754             final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
1755             builders.put(genTypeName, newType);
1756             genTypeBuilders.put(packageName, builders);
1757         } else {
1758             final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);
1759             if (!builders.containsKey(genTypeName)) {
1760                 builders.put(genTypeName, newType);
1761             }
1762         }
1763         return newType;
1764     }
1765
1766     /**
1767      * Creates the name of the getter method name from <code>localName</code>.
1768      *
1769      * @param localName
1770      *            string with the name of the getter method
1771      * @param returnType
1772      *            return type
1773      * @return string with the name of the getter method for
1774      *         <code>methodName</code> in JAVA method format
1775      */
1776     public static String getterMethodName(final String localName, final Type returnType) {
1777         final StringBuilder method = new StringBuilder();
1778         if (BOOLEAN.equals(returnType)) {
1779             method.append("is");
1780         } else {
1781             method.append("get");
1782         }
1783         String name = BindingMapping.toFirstUpper(BindingMapping.getPropertyName(localName));
1784         method.append(name);
1785         return method.toString();
1786     }
1787
1788     /**
1789      * Created a method signature builder as part of
1790      * <code>interfaceBuilder</code>.
1791      *
1792      * The method signature builder is created for the getter method of
1793      * <code>schemaNodeName</code>. Also <code>comment</code> and
1794      * <code>returnType</code> information are added to the builder.
1795      *
1796      * @param interfaceBuilder
1797      *            generated type builder for which the getter method should be
1798      *            created
1799      * @param schemaNodeName
1800      *            string with schema node name. The name will be the part of the
1801      *            getter method name.
1802      * @param comment
1803      *            string with comment for the getter method
1804      * @param returnType
1805      *            type which represents the return type of the getter method
1806      * @return method signature builder which represents the getter method of
1807      *         <code>interfaceBuilder</code>
1808      */
1809     private MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,
1810             final String schemaNodeName, final String comment, final Type returnType) {
1811         final MethodSignatureBuilder getMethod = interfaceBuilder
1812                 .addMethod(getterMethodName(schemaNodeName, returnType));
1813         getMethod.setComment(comment);
1814         getMethod.setReturnType(returnType);
1815         return getMethod;
1816     }
1817
1818     /**
1819      * Adds <code>schemaNode</code> to <code>typeBuilder</code> as getter method
1820      * or to <code>genTOBuilder</code> as property.
1821      *
1822      * @param basePackageName
1823      *            string contains the module package name
1824      * @param schemaNode
1825      *            data schema node which should be added as getter method to
1826      *            <code>typeBuilder</code> or as a property to
1827      *            <code>genTOBuilder</code> if is part of the list key
1828      * @param typeBuilder
1829      *            generated type builder for the list schema node
1830      * @param genTOBuilder
1831      *            generated TO builder for the list keys
1832      * @param listKeys
1833      *            list of string which contains names of the list keys
1834      * @param module
1835      *            current module
1836      * @throws IllegalArgumentException
1837      *             <ul>
1838      *             <li>if <code>schemaNode</code> equals null</li>
1839      *             <li>if <code>typeBuilder</code> equals null</li>
1840      *             </ul>
1841      */
1842     private void addSchemaNodeToListBuilders(final String basePackageName, final DataSchemaNode schemaNode,
1843             final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder, final List<String> listKeys,
1844             final Module module) {
1845         checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
1846         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
1847
1848         if (schemaNode instanceof LeafSchemaNode) {
1849             final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;
1850             final String leafName = leaf.getQName().getLocalName();
1851             final Type type = resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);
1852             if (listKeys.contains(leafName)) {
1853                 if (type == null) {
1854                     resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true, module);
1855                 } else {
1856                     resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, type, true);
1857                 }
1858             }
1859         } else if (!schemaNode.isAddedByUses()) {
1860             if (schemaNode instanceof LeafListSchemaNode) {
1861                 resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);
1862             } else if (schemaNode instanceof ContainerSchemaNode) {
1863                 containerToGenType(module, basePackageName, typeBuilder, typeBuilder, (ContainerSchemaNode) schemaNode);
1864             } else if (schemaNode instanceof ChoiceNode) {
1865                 choiceToGeneratedType(module, basePackageName, typeBuilder, (ChoiceNode) schemaNode);
1866             } else if (schemaNode instanceof ListSchemaNode) {
1867                 listToGenType(module, basePackageName, typeBuilder, typeBuilder, (ListSchemaNode) schemaNode);
1868             }
1869         }
1870     }
1871
1872     private void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder,
1873             final GeneratedTOBuilder genTOBuilder) {
1874         checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
1875
1876         if (genTOBuilder != null) {
1877             GeneratedTransferObject genTO = genTOBuilder.toInstance();
1878             constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO);
1879             genCtx.get(module).addGeneratedTOBuilder(genTOBuilder);
1880         }
1881     }
1882
1883     /**
1884      * Selects the names of the list keys from <code>list</code> and returns
1885      * them as the list of the strings
1886      *
1887      * @param list
1888      *            of string with names of the list keys
1889      * @return list of string which represents names of the list keys. If the
1890      *         <code>list</code> contains no keys then the empty list is
1891      *         returned.
1892      */
1893     private List<String> listKeys(final ListSchemaNode list) {
1894         final List<String> listKeys = new ArrayList<>();
1895
1896         List<QName> keyDefinition = list.getKeyDefinition();
1897         if (keyDefinition != null) {
1898             for (QName keyDef : keyDefinition) {
1899                 listKeys.add(keyDef.getLocalName());
1900             }
1901         }
1902         return listKeys;
1903     }
1904
1905     /**
1906      * Generates for the <code>list</code> which contains any list keys special
1907      * generated TO builder.
1908      *
1909      * @param packageName
1910      *            string with package name to which the list belongs
1911      * @param list
1912      *            list schema node which is source of data about the list name
1913      * @return generated TO builder which represents the keys of the
1914      *         <code>list</code> or null if <code>list</code> is null or list of
1915      *         key definitions is null or empty.
1916      */
1917     private GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list) {
1918         GeneratedTOBuilder genTOBuilder = null;
1919         if ((list.getKeyDefinition() != null) && (!list.getKeyDefinition().isEmpty())) {
1920             final String listName = list.getQName().getLocalName() + "Key";
1921             final String genTOName = BindingMapping.getClassName(listName);
1922             genTOBuilder = new GeneratedTOBuilderImpl(packageName, genTOName);
1923         }
1924         return genTOBuilder;
1925     }
1926
1927     /**
1928      * Builds generated TO builders for <code>typeDef</code> of type
1929      * {@link org.opendaylight.yangtools.yang.model.util.UnionType UnionType} or
1930      * {@link org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition
1931      * BitsTypeDefinition} which are also added to <code>typeBuilder</code> as
1932      * enclosing transfer object.
1933      *
1934      * If more then one generated TO builder is created for enclosing then all
1935      * of the generated TO builders are added to <code>typeBuilder</code> as
1936      * enclosing transfer objects.
1937      *
1938      * @param typeDef
1939      *            type definition which can be of type <code>UnionType</code> or
1940      *            <code>BitsTypeDefinition</code>
1941      * @param typeBuilder
1942      *            generated type builder to which is added generated TO created
1943      *            from <code>typeDef</code>
1944      * @param leafName
1945      *            string with name for generated TO builder
1946      * @param leaf
1947      * @return generated TO builder for <code>typeDef</code>
1948      */
1949     private GeneratedTOBuilder addTOToTypeBuilder(final TypeDefinition<?> typeDef,
1950             final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
1951         final String classNameFromLeaf = BindingMapping.getClassName(leaf.getQName());
1952         final List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>();
1953         final String packageName = typeBuilder.getFullyQualifiedName();
1954         if (typeDef instanceof UnionTypeDefinition) {
1955             final List<GeneratedTOBuilder> types = ((TypeProviderImpl) typeProvider)
1956                     .provideGeneratedTOBuildersForUnionTypeDef(packageName, ((UnionTypeDefinition) typeDef),
1957                             classNameFromLeaf, leaf);
1958             genTOBuilders.addAll(types);
1959
1960             GeneratedTOBuilder resultTOBuilder = null;
1961             if (types.isEmpty()) {
1962                 throw new IllegalStateException("No GeneratedTOBuilder objects generated from union " + typeDef);
1963             }
1964             resultTOBuilder = types.remove(0);
1965             for (GeneratedTOBuilder genTOBuilder : types) {
1966                 resultTOBuilder.addEnclosingTransferObject(genTOBuilder);
1967             }
1968
1969             final GeneratedPropertyBuilder genPropBuilder = resultTOBuilder.addProperty("value");
1970             genPropBuilder.setReturnType(Types.primitiveType("char[]", null));
1971             resultTOBuilder.addEqualsIdentity(genPropBuilder);
1972             resultTOBuilder.addHashIdentity(genPropBuilder);
1973             resultTOBuilder.addToStringProperty(genPropBuilder);
1974
1975         } else if (typeDef instanceof BitsTypeDefinition) {
1976             genTOBuilders.add((((TypeProviderImpl) typeProvider)).provideGeneratedTOBuilderForBitsTypeDefinition(
1977                     packageName, typeDef, classNameFromLeaf, parentModule.getName()));
1978         }
1979         if (genTOBuilders != null && !genTOBuilders.isEmpty()) {
1980             for (GeneratedTOBuilder genTOBuilder : genTOBuilders) {
1981                 typeBuilder.addEnclosingTransferObject(genTOBuilder);
1982             }
1983             return genTOBuilders.get(0);
1984         }
1985         return null;
1986
1987     }
1988
1989     /**
1990      * Adds the implemented types to type builder.
1991      *
1992      * The method passes through the list of <i>uses</i> in
1993      * {@code dataNodeContainer}. For every <i>use</i> is obtained corresponding
1994      * generated type from {@link BindingGeneratorImpl#allGroupings
1995      * allGroupings} which is added as <i>implements type</i> to
1996      * <code>builder</code>
1997      *
1998      * @param dataNodeContainer
1999      *            element which contains the list of used YANG groupings
2000      * @param builder
2001      *            builder to which are added implemented types according to
2002      *            <code>dataNodeContainer</code>
2003      * @return generated type builder with all implemented types
2004      */
2005     private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,
2006             final GeneratedTypeBuilder builder) {
2007         for (UsesNode usesNode : dataNodeContainer.getUses()) {
2008             if (usesNode.getGroupingPath() != null) {
2009                 final GeneratedType genType = findGroupingByPath(usesNode.getGroupingPath()).toInstance();
2010                 if (genType == null) {
2011                     throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "
2012                             + builder.getName());
2013                 }
2014
2015                 builder.addImplementsType(genType);
2016                 /*
2017                 builder.addComment(genType.getDescription());
2018                 builder.setDescription(genType.getDescription());
2019                 builder.setModuleName(genType.getModuleName());
2020                 builder.setReference(genType.getReference());
2021                 builder.setSchemaPath(genType.getSchemaPath());
2022                 */
2023             }
2024         }
2025         return builder;
2026     }
2027
2028     private boolean isNullOrEmpty(final Collection<?> list) {
2029         return (list == null || list.isEmpty() ? true : false);
2030     }
2031
2032     private String createDescription(final Set<? extends SchemaNode> schemaNodes, final String moduleName, final String moduleSourcePath) {
2033         final StringBuilder sb = new StringBuilder();
2034
2035         if (!isNullOrEmpty(schemaNodes)) {
2036             final SchemaNode node = schemaNodes.iterator().next();
2037
2038             if (node instanceof RpcDefinition) {
2039                 sb.append("Interface for implementing the following YANG RPCs defined in module <b>" + moduleName + "</b>");
2040             } else if (node instanceof NotificationDefinition) {
2041                 sb.append("Interface for receiving the following YANG notifications defined in module <b>" + moduleName + "</b>");
2042             }
2043         }
2044         sb.append(NEW_LINE);
2045         sb.append("<br />(Source path: <i>");
2046         sb.append(moduleSourcePath);
2047         sb.append("</i>):");
2048         sb.append(NEW_LINE);
2049
2050         if (verboseClassComments) {
2051             sb.append("<pre>");
2052             sb.append(NEW_LINE);
2053             sb.append(YangTemplate.generateYangSnipet(schemaNodes));
2054             sb.append("</pre>");
2055             sb.append(NEW_LINE);
2056         }
2057
2058         return sb.toString();
2059     }
2060
2061     private String createDescription(final SchemaNode schemaNode, final String fullyQualifiedName) {
2062         final StringBuilder sb = new StringBuilder();
2063         final String formattedDescription = YangTemplate.formatToParagraph(schemaNode.getDescription(), 0);
2064
2065         if (!isNullOrEmpty(formattedDescription)) {
2066             sb.append(formattedDescription);
2067             sb.append(NEW_LINE);
2068         }
2069
2070         if (verboseClassComments) {
2071             final Module module = findParentModule(schemaContext, schemaNode);
2072             final StringBuilder linkToBuilderClass = new StringBuilder();
2073             final StringBuilder linkToKeyClass = new StringBuilder();
2074             final String[] namespace = Iterables.toArray(BSDOT_SPLITTER.split(fullyQualifiedName), String.class);
2075             String className = namespace[namespace.length - 1];
2076
2077             if (hasBuilderClass(schemaNode)) {
2078                 linkToBuilderClass.append(className);
2079                 linkToBuilderClass.append("Builder");
2080
2081                 if (schemaNode instanceof ListSchemaNode) {
2082                     linkToKeyClass.append(className);
2083                     linkToKeyClass.append("Key");
2084                 }
2085             }
2086
2087             sb.append("<p>");
2088             sb.append("This class represents the following YANG schema fragment defined in module <b>");
2089             sb.append(module.getName());
2090             sb.append("</b>");
2091             sb.append(NEW_LINE);
2092             sb.append("<br />(Source path: <i>");
2093             sb.append(module.getModuleSourcePath());
2094             sb.append("</i>):");
2095             sb.append(NEW_LINE);
2096             sb.append("<pre>");
2097             sb.append(NEW_LINE);
2098             sb.append(YangTemplate.generateYangSnipet(schemaNode));
2099             sb.append("</pre>");
2100             sb.append(NEW_LINE);
2101             sb.append("The schema path to identify an instance is");
2102             sb.append(NEW_LINE);
2103             sb.append("<i>");
2104             sb.append(YangTemplate.formatSchemaPath(module.getName(), schemaNode.getPath().getPathFromRoot()));
2105             sb.append("</i>");
2106             sb.append(NEW_LINE);
2107
2108             if (hasBuilderClass(schemaNode)) {
2109                 sb.append(NEW_LINE);
2110                 sb.append("<p>To create instances of this class use " + "{@link " + linkToBuilderClass + "}.");
2111                 sb.append(NEW_LINE);
2112                 sb.append("@see ");
2113                 sb.append(linkToBuilderClass);
2114                 if (schemaNode instanceof ListSchemaNode) {
2115                     sb.append("@see ");
2116                     sb.append(linkToKeyClass);
2117                 }
2118                 sb.append(NEW_LINE);
2119             }
2120         }
2121
2122         return sb.toString();
2123     }
2124
2125     private boolean hasBuilderClass(final SchemaNode schemaNode) {
2126         if (schemaNode instanceof ContainerSchemaNode || schemaNode instanceof ListSchemaNode ||
2127                 schemaNode instanceof RpcDefinition || schemaNode instanceof NotificationDefinition) {
2128             return true;
2129         }
2130         return false;
2131     }
2132
2133     private boolean isNullOrEmpty(final String string) {
2134         return (string == null || string.isEmpty() ? true : false);
2135     }
2136
2137     private String createDescription(final Module module) {
2138         final StringBuilder sb = new StringBuilder();
2139         final String formattedDescription = YangTemplate.formatToParagraph(module.getDescription(), 0);
2140
2141         if (!isNullOrEmpty(formattedDescription)) {
2142             sb.append(formattedDescription);
2143             sb.append(NEW_LINE);
2144         }
2145
2146         if (verboseClassComments) {
2147             sb.append("<p>");
2148             sb.append("This class represents the following YANG schema fragment defined in module <b>");
2149             sb.append(module.getName());
2150             sb.append("</b>");
2151             sb.append(NEW_LINE);
2152             sb.append("<br />Source path: <i>");
2153             sb.append(module.getModuleSourcePath());
2154             sb.append("</i>):");
2155             sb.append(NEW_LINE);
2156             sb.append("<pre>");
2157             sb.append(NEW_LINE);
2158             sb.append(YangTemplate.generateYangSnipet(module));
2159             sb.append("</pre>");
2160         }
2161
2162         return sb.toString();
2163     }
2164
2165     private GeneratedTypeBuilder findChildNodeByPath(final SchemaPath path) {
2166         for (ModuleContext ctx : genCtx.values()) {
2167             GeneratedTypeBuilder result = ctx.getChildNode(path);
2168             if (result != null) {
2169                 return result;
2170             }
2171         }
2172         return null;
2173     }
2174
2175     private GeneratedTypeBuilder findGroupingByPath(final SchemaPath path) {
2176         for (ModuleContext ctx : genCtx.values()) {
2177             GeneratedTypeBuilder result = ctx.getGrouping(path);
2178             if (result != null) {
2179                 return result;
2180             }
2181         }
2182         return null;
2183     }
2184
2185     private GeneratedTypeBuilder findCaseByPath(final SchemaPath path) {
2186         for (ModuleContext ctx : genCtx.values()) {
2187             GeneratedTypeBuilder result = ctx.getCase(path);
2188             if (result != null) {
2189                 return result;
2190             }
2191         }
2192         return null;
2193     }
2194
2195     public Map<Module, ModuleContext> getModuleContexts() {
2196         return genCtx;
2197     }
2198
2199 }