opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/builder/impl/ModuleBuilder.java

   1 /*\r
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 package org.opendaylight.controller.yang.model.parser.builder.impl;\r
   9 \r
  10 import java.net.URI;\r
  11 import java.util.ArrayList;\r
  12 import java.util.Collections;\r
  13 import java.util.Date;\r
  14 import java.util.HashMap;\r
  15 import java.util.HashSet;\r
  16 import java.util.List;\r
  17 import java.util.Map;\r
  18 import java.util.Set;\r
  19 \r
  20 import org.opendaylight.controller.yang.common.QName;\r
  21 import org.opendaylight.controller.yang.model.api.AugmentationSchema;\r
  22 import org.opendaylight.controller.yang.model.api.DataSchemaNode;\r
  23 import org.opendaylight.controller.yang.model.api.Deviation;\r
  24 import org.opendaylight.controller.yang.model.api.ExtensionDefinition;\r
  25 import org.opendaylight.controller.yang.model.api.FeatureDefinition;\r
  26 import org.opendaylight.controller.yang.model.api.GroupingDefinition;\r
  27 import org.opendaylight.controller.yang.model.api.IdentitySchemaNode;\r
  28 import org.opendaylight.controller.yang.model.api.Module;\r
  29 import org.opendaylight.controller.yang.model.api.ModuleImport;\r
  30 import org.opendaylight.controller.yang.model.api.NotificationDefinition;\r
  31 import org.opendaylight.controller.yang.model.api.RpcDefinition;\r
  32 import org.opendaylight.controller.yang.model.api.TypeDefinition;\r
  33 import org.opendaylight.controller.yang.model.api.UsesNode;\r
  34 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationSchemaBuilder;\r
  35 import org.opendaylight.controller.yang.model.parser.builder.api.Builder;\r
  36 import org.opendaylight.controller.yang.model.parser.builder.api.ChildNodeBuilder;\r
  37 import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;\r
  38 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;\r
  39 import org.opendaylight.controller.yang.model.parser.builder.api.TypeAwareBuilder;\r
  40 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionAwareBuilder;\r
  41 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;\r
  42 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;\r
  43 \r
  44 /**\r
  45  * This builder builds Module object. If this module is dependent on external\r
  46  * module/modules, these dependencies must be resolved before module is built,\r
  47  * otherwise result may not be valid.\r
  48  */\r
  49 public class ModuleBuilder implements Builder {\r
  50 \r
  51     private final ModuleImpl instance;\r
  52     private final String name;\r
  53     private String prefix;\r
  54     private Date revision;\r
  55 \r
  56     private final Set<ModuleImport> imports = new HashSet<ModuleImport>();\r
  57     private Set<AugmentationSchema> augmentations;\r
  58 \r
  59     /**\r
  60      * All nodes, that can contain other nodes\r
  61      */\r
  62     private final Map<List<String>, Builder> moduleNodes = new HashMap<List<String>, Builder>();\r
  63 \r
  64     /**\r
  65      * Holds all child (DataSchemaNode) nodes: anyxml, choice, case, container,\r
  66      * list, leaf, leaf-list.\r
  67      */\r
  68     private final Map<List<String>, DataSchemaNodeBuilder> addedChilds = new HashMap<List<String>, DataSchemaNodeBuilder>();\r
  69 \r
  70     private final Map<List<String>, GroupingBuilder> addedGroupings = new HashMap<List<String>, GroupingBuilder>();\r
  71     private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();\r
  72     private final Map<List<String>, UsesNodeBuilder> addedUsesNodes = new HashMap<List<String>, UsesNodeBuilder>();\r
  73     private final Map<List<String>, RpcDefinitionBuilder> addedRpcs = new HashMap<List<String>, RpcDefinitionBuilder>();\r
  74     private final Set<NotificationBuilder> addedNotifications = new HashSet<NotificationBuilder>();\r
  75     private final Set<IdentitySchemaNodeBuilder> addedIdentities = new HashSet<IdentitySchemaNodeBuilder>();\r
  76     private final Map<List<String>, FeatureBuilder> addedFeatures = new HashMap<List<String>, FeatureBuilder>();\r
  77     private final Map<String, DeviationBuilder> addedDeviations = new HashMap<String, DeviationBuilder>();\r
  78     private final Map<List<String>, TypeDefinitionBuilder> addedTypedefs = new HashMap<List<String>, TypeDefinitionBuilder>();\r
  79     private final List<ExtensionBuilder> addedExtensions = new ArrayList<ExtensionBuilder>();\r
  80 \r
  81     private final Map<List<String>, TypeAwareBuilder> dirtyNodes = new HashMap<List<String>, TypeAwareBuilder>();\r
  82     private final Map<List<String>, UnionTypeBuilder> unionTypes = new HashMap<List<String>, UnionTypeBuilder>();\r
  83 \r
  84     public ModuleBuilder(String name) {\r
  85         this.name = name;\r
  86         instance = new ModuleImpl(name);\r
  87     }\r
  88 \r
  89 \r
  90     /**\r
  91      * Build new Module object based on this builder.\r
  92      */\r
  93     @Override\r
  94     public Module build() {\r
  95         instance.setImports(imports);\r
  96 \r
  97         // TYPEDEFS\r
  98         final Set<TypeDefinition<?>> typedefs = buildModuleTypedefs(addedTypedefs);\r
  99         instance.setTypeDefinitions(typedefs);\r
 100 \r
 101         // CHILD NODES\r
 102         final Map<QName, DataSchemaNode> childNodes = buildModuleChildNodes(addedChilds);\r
 103         instance.setChildNodes(childNodes);\r
 104 \r
 105         // GROUPINGS\r
 106         final Set<GroupingDefinition> groupings = buildModuleGroupings(addedGroupings);\r
 107         instance.setGroupings(groupings);\r
 108 \r
 109         // USES\r
 110         final Set<UsesNode> usesNodeDefinitions = buildUsesNodes(addedUsesNodes);\r
 111         instance.setUses(usesNodeDefinitions);\r
 112 \r
 113         // FEATURES\r
 114         final Set<FeatureDefinition> features = buildModuleFeatures(addedFeatures);\r
 115         instance.setFeatures(features);\r
 116 \r
 117         // NOTIFICATIONS\r
 118         final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();\r
 119         for (NotificationBuilder entry : addedNotifications) {\r
 120             notifications.add((NotificationDefinition) entry.build());\r
 121         }\r
 122         instance.setNotifications(notifications);\r
 123 \r
 124         // AUGMENTATIONS\r
 125         instance.setAugmentations(augmentations);\r
 126 \r
 127         // RPCs\r
 128         final Set<RpcDefinition> rpcs = buildModuleRpcs(addedRpcs);\r
 129         instance.setRpcs(rpcs);\r
 130 \r
 131         // DEVIATIONS\r
 132         final Set<Deviation> deviations = new HashSet<Deviation>();\r
 133         for (Map.Entry<String, DeviationBuilder> entry : addedDeviations\r
 134                 .entrySet()) {\r
 135             deviations.add(entry.getValue().build());\r
 136         }\r
 137         instance.setDeviations(deviations);\r
 138 \r
 139         // EXTENSIONS\r
 140         final List<ExtensionDefinition> extensions = new ArrayList<ExtensionDefinition>();\r
 141         for(ExtensionBuilder b : addedExtensions) {\r
 142             extensions.add(b.build());\r
 143         }\r
 144         instance.setExtensionSchemaNodes(extensions);\r
 145 \r
 146         // IDENTITIES\r
 147         final Set<IdentitySchemaNode> identities = new HashSet<IdentitySchemaNode>();\r
 148         for(IdentitySchemaNodeBuilder idBuilder : addedIdentities) {\r
 149             identities.add(idBuilder.build());\r
 150         }\r
 151         instance.setIdentities(identities);\r
 152 \r
 153         return instance;\r
 154     }\r
 155 \r
 156     public Builder getNode(List<String> path) {\r
 157         return moduleNodes.get(path);\r
 158     }\r
 159 \r
 160     public Map<List<String>, TypeAwareBuilder> getDirtyNodes() {\r
 161         return dirtyNodes;\r
 162     }\r
 163 \r
 164     public Set<AugmentationSchemaBuilder> getAddedAugments() {\r
 165         return addedAugments;\r
 166     }\r
 167 \r
 168     public Set<IdentitySchemaNodeBuilder> getAddedIdentities() {\r
 169         return addedIdentities;\r
 170     }\r
 171 \r
 172     public String getName() {\r
 173         return name;\r
 174     }\r
 175 \r
 176     public String getPrefix() {\r
 177         return prefix;\r
 178     }\r
 179 \r
 180     public Date getRevision() {\r
 181         return revision;\r
 182     }\r
 183 \r
 184     public void addDirtyNode(List<String> path) {\r
 185         List<String> dirtyNodePath = new ArrayList<String>(path);\r
 186         TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) moduleNodes\r
 187                 .get(dirtyNodePath);\r
 188         dirtyNodes.put(dirtyNodePath, nodeBuilder);\r
 189     }\r
 190 \r
 191     public void setNamespace(URI namespace) {\r
 192         instance.setNamespace(namespace);\r
 193     }\r
 194 \r
 195     public void setRevision(Date revision) {\r
 196         this.revision = revision;\r
 197         instance.setRevision(revision);\r
 198     }\r
 199 \r
 200     public void setPrefix(String prefix) {\r
 201         this.prefix = prefix;\r
 202         instance.setPrefix(prefix);\r
 203     }\r
 204 \r
 205     public void setYangVersion(String yangVersion) {\r
 206         instance.setYangVersion(yangVersion);\r
 207     }\r
 208 \r
 209     public void setDescription(String description) {\r
 210         instance.setDescription(description);\r
 211     }\r
 212 \r
 213     public void setReference(String reference) {\r
 214         instance.setReference(reference);\r
 215     }\r
 216 \r
 217     public void setOrganization(String organization) {\r
 218         instance.setOrganization(organization);\r
 219     }\r
 220 \r
 221     public void setContact(String contact) {\r
 222         instance.setContact(contact);\r
 223     }\r
 224 \r
 225     public void setAugmentations(Set<AugmentationSchema> augmentations) {\r
 226         this.augmentations = augmentations;\r
 227     }\r
 228 \r
 229     public boolean addModuleImport(final String moduleName,\r
 230             final Date revision, final String prefix) {\r
 231         ModuleImport moduleImport = createModuleImport(moduleName, revision,\r
 232                 prefix);\r
 233         return imports.add(moduleImport);\r
 234     }\r
 235 \r
 236     public Set<ModuleImport> getModuleImports() {\r
 237         return imports;\r
 238     }\r
 239 \r
 240     public ExtensionBuilder addExtension(QName qname) {\r
 241         ExtensionBuilder builder = new ExtensionBuilder(qname);\r
 242         return builder;\r
 243     }\r
 244 \r
 245     public ContainerSchemaNodeBuilder addContainerNode(QName containerName,\r
 246             List<String> parentPath) {\r
 247         List<String> pathToNode = new ArrayList<String>(parentPath);\r
 248 \r
 249         ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(\r
 250                 containerName);\r
 251 \r
 252         ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes\r
 253                 .get(pathToNode);\r
 254         if (parent != null) {\r
 255             if(parent instanceof AugmentationSchemaBuilder) {\r
 256                 containerBuilder.setAugmenting(true);\r
 257             }\r
 258             parent.addChildNode(containerBuilder);\r
 259         }\r
 260 \r
 261         pathToNode.add(containerName.getLocalName());\r
 262         moduleNodes.put(pathToNode, containerBuilder);\r
 263         addedChilds.put(pathToNode, containerBuilder);\r
 264 \r
 265         return containerBuilder;\r
 266     }\r
 267 \r
 268     public ListSchemaNodeBuilder addListNode(QName listName,\r
 269             List<String> parentPath) {\r
 270         List<String> pathToNode = new ArrayList<String>(parentPath);\r
 271 \r
 272         ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(listName);\r
 273 \r
 274         ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes\r
 275                 .get(pathToNode);\r
 276         if (parent != null) {\r
 277             if(parent instanceof AugmentationSchemaBuilder) {\r
 278                 listBuilder.setAugmenting(true);\r
 279             }\r
 280             parent.addChildNode(listBuilder);\r
 281         }\r
 282 \r
 283         pathToNode.add(listName.getLocalName());\r
 284         moduleNodes.put(pathToNode, listBuilder);\r
 285         addedChilds.put(pathToNode, listBuilder);\r
 286 \r
 287         return listBuilder;\r
 288     }\r
 289 \r
 290     public LeafSchemaNodeBuilder addLeafNode(QName leafName,\r
 291             List<String> parentPath) {\r
 292         List<String> pathToNode = new ArrayList<String>(parentPath);\r
 293 \r
 294         LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(leafName);\r
 295 \r
 296         ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes.get(pathToNode);\r
 297         if (parent != null) {\r
 298             if(parent instanceof AugmentationSchemaBuilder) {\r
 299                 leafBuilder.setAugmenting(true);\r
 300             }\r
 301             parent.addChildNode(leafBuilder);\r
 302         }\r
 303 \r
 304         pathToNode.add(leafName.getLocalName());\r
 305         addedChilds.put(pathToNode, leafBuilder);\r
 306         moduleNodes.put(pathToNode, leafBuilder);\r
 307 \r
 308         return leafBuilder;\r
 309     }\r
 310 \r
 311     public LeafListSchemaNodeBuilder addLeafListNode(QName leafListName,\r
 312             List<String> parentPath) {\r
 313         List<String> pathToNode = new ArrayList<String>(parentPath);\r
 314 \r
 315         LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(\r
 316                 leafListName);\r
 317         ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes.get(pathToNode);\r
 318         if (parent != null) {\r
 319             if(parent instanceof AugmentationSchemaBuilder) {\r
 320                 leafListBuilder.setAugmenting(true);\r
 321             }\r
 322             parent.addChildNode(leafListBuilder);\r
 323         }\r
 324 \r
 325         pathToNode.add(leafListName.getLocalName());\r
 326         addedChilds.put(pathToNode, leafListBuilder);\r
 327         moduleNodes.put(pathToNode, leafListBuilder);\r
 328 \r
 329         return leafListBuilder;\r
 330     }\r
 331 \r
 332     public GroupingBuilder addGrouping(QName qname, List<String> parentPath) {\r
 333         List<String> pathToGroup = new ArrayList<String>(parentPath);\r
 334 \r
 335         GroupingBuilder builder = new GroupingBuilderImpl(qname);\r
 336         ChildNodeBuilder parentNodeBuilder = (ChildNodeBuilder) moduleNodes.get(pathToGroup);\r
 337         if (parentNodeBuilder != null) {\r
 338             parentNodeBuilder.addGrouping(builder);\r
 339         }\r
 340 \r
 341         pathToGroup.add(qname.getLocalName());\r
 342         moduleNodes.put(pathToGroup, builder);\r
 343         addedGroupings.put(pathToGroup, builder);\r
 344 \r
 345         return builder;\r
 346     }\r
 347 \r
 348     public AugmentationSchemaBuilder addAugment(String name,\r
 349             List<String> parentPath) {\r
 350         List<String> pathToAugment = new ArrayList<String>(parentPath);\r
 351 \r
 352         AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(name);\r
 353 \r
 354         // augment can only be in 'module' or 'uses' statement\r
 355         UsesNodeBuilder parent = addedUsesNodes.get(pathToAugment);\r
 356         if (parent != null) {\r
 357             parent.addAugment(builder);\r
 358         }\r
 359 \r
 360         pathToAugment.add(name);\r
 361         moduleNodes.put(pathToAugment, builder);\r
 362         addedAugments.add(builder);\r
 363 \r
 364         return builder;\r
 365     }\r
 366 \r
 367     public UsesNodeBuilder addUsesNode(String groupingPathStr,\r
 368             List<String> parentPath) {\r
 369         List<String> pathToUses = new ArrayList<String>(parentPath);\r
 370 \r
 371         UsesNodeBuilder usesBuilder = new UsesNodeBuilderImpl(groupingPathStr);\r
 372 \r
 373         ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes.get(pathToUses);\r
 374         if (parent != null) {\r
 375             if(parent instanceof AugmentationSchemaBuilder) {\r
 376                 usesBuilder.setAugmenting(true);\r
 377             }\r
 378             parent.addUsesNode(usesBuilder);\r
 379         }\r
 380 \r
 381         pathToUses.add(groupingPathStr);\r
 382         addedUsesNodes.put(pathToUses, usesBuilder);\r
 383 \r
 384         return usesBuilder;\r
 385     }\r
 386 \r
 387     public RpcDefinitionBuilder addRpc(QName qname, List<String> parentPath) {\r
 388         List<String> pathToRpc = new ArrayList<String>(parentPath);\r
 389 \r
 390         RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(qname);\r
 391 \r
 392         pathToRpc.add(qname.getLocalName());\r
 393         addedRpcs.put(pathToRpc, rpcBuilder);\r
 394 \r
 395         QName inputQName = new QName(qname.getNamespace(), qname.getRevision(),\r
 396                 qname.getPrefix(), "input");\r
 397         ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(inputQName);\r
 398         List<String> pathToInput = new ArrayList<String>(pathToRpc);\r
 399         pathToInput.add("input");\r
 400         moduleNodes.put(pathToInput, inputBuilder);\r
 401         rpcBuilder.setInput(inputBuilder);\r
 402 \r
 403         QName outputQName = new QName(qname.getNamespace(),\r
 404                 qname.getRevision(), qname.getPrefix(), "output");\r
 405         ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(outputQName);\r
 406         List<String> pathToOutput = new ArrayList<String>(pathToRpc);\r
 407         pathToOutput.add("output");\r
 408         moduleNodes.put(pathToOutput, outputBuilder);\r
 409         rpcBuilder.setOutput(outputBuilder);\r
 410 \r
 411         return rpcBuilder;\r
 412     }\r
 413 \r
 414     public NotificationBuilder addNotification(QName notificationName,\r
 415             List<String> parentPath) {\r
 416         List<String> pathToNotification = new ArrayList<String>(parentPath);\r
 417 \r
 418         NotificationBuilder notificationBuilder = new NotificationBuilder(\r
 419                 notificationName);\r
 420 \r
 421         pathToNotification.add(notificationName.getLocalName());\r
 422         moduleNodes.put(pathToNotification, notificationBuilder);\r
 423         addedNotifications.add(notificationBuilder);\r
 424 \r
 425         return notificationBuilder;\r
 426     }\r
 427 \r
 428     public FeatureBuilder addFeature(QName featureName, List<String> parentPath) {\r
 429         List<String> pathToFeature = new ArrayList<String>(parentPath);\r
 430         pathToFeature.add(featureName.getLocalName());\r
 431 \r
 432         FeatureBuilder builder = new FeatureBuilder(featureName);\r
 433         addedFeatures.put(pathToFeature, builder);\r
 434         return builder;\r
 435     }\r
 436 \r
 437     public TypedefBuilder addTypedef(QName typeDefName, List<String> parentPath) {\r
 438         List<String> pathToType = new ArrayList<String>(parentPath);\r
 439         TypedefBuilder builder = new TypedefBuilder(typeDefName);\r
 440         TypeDefinitionAwareBuilder parent = (TypeDefinitionAwareBuilder) moduleNodes.get(pathToType);\r
 441         if (parent != null) {\r
 442             parent.addTypedef(builder);\r
 443         }\r
 444         pathToType.add(typeDefName.getLocalName());\r
 445         addedTypedefs.put(pathToType, builder);\r
 446         moduleNodes.put(pathToType, builder);\r
 447         return builder;\r
 448     }\r
 449 \r
 450     public Set<TypeDefinitionBuilder> getModuleTypedefs() {\r
 451         Set<TypeDefinitionBuilder> typedefs = new HashSet<TypeDefinitionBuilder>();\r
 452         for (Map.Entry<List<String>, TypeDefinitionBuilder> entry : addedTypedefs.entrySet()) {\r
 453             if (entry.getKey().size() == 2) {\r
 454                 typedefs.add(entry.getValue());\r
 455             }\r
 456         }\r
 457         return typedefs;\r
 458     }\r
 459 \r
 460     public void setType(TypeDefinition<?> type, List<String> parentPath) {\r
 461         TypeAwareBuilder parent = (TypeAwareBuilder) moduleNodes.get(parentPath);\r
 462         parent.setType(type);\r
 463     }\r
 464 \r
 465     public void addUnionType(List<String> parentPath) {\r
 466         TypeAwareBuilder parent = (TypeAwareBuilder) moduleNodes.get(parentPath);\r
 467         UnionTypeBuilder union = new UnionTypeBuilder();\r
 468         parent.setType(union.build());\r
 469 \r
 470         List<String> path = new ArrayList<String>(parentPath);\r
 471         path.add("union");\r
 472 \r
 473         unionTypes.put(path, union);\r
 474         moduleNodes.put(path, union);\r
 475     }\r
 476 \r
 477     public DeviationBuilder addDeviation(String targetPath) {\r
 478         DeviationBuilder builder = new DeviationBuilder(targetPath);\r
 479         addedDeviations.put(targetPath, builder);\r
 480         return builder;\r
 481     }\r
 482 \r
 483     public IdentitySchemaNodeBuilder addIdentity(QName qname) {\r
 484         IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(qname);\r
 485         addedIdentities.add(builder);\r
 486 \r
 487         return builder;\r
 488     }\r
 489 \r
 490     public void addConfiguration(boolean configuration, List<String> parentPath) {\r
 491         Builder builder = moduleNodes.get(parentPath);\r
 492         if (builder instanceof DeviationBuilder) {\r
 493             // skip\r
 494             // TODO\r
 495         } else {\r
 496             DataSchemaNodeBuilder configBuilder = (DataSchemaNodeBuilder) moduleNodes.get(parentPath);\r
 497             configBuilder.setConfiguration(configuration);\r
 498         }\r
 499     }\r
 500 \r
 501     public UnknownSchemaNodeBuilder addUnknownSchemaNode(QName qname, List<String> parentPath) {\r
 502         UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(qname);\r
 503         return builder;\r
 504     }\r
 505 \r
 506 \r
 507     private class ModuleImpl implements Module {\r
 508         private URI namespace;\r
 509         private final String name;\r
 510         private Date revision;\r
 511         private String prefix;\r
 512         private String yangVersion;\r
 513         private String description;\r
 514         private String reference;\r
 515         private String organization;\r
 516         private String contact;\r
 517         private Set<ModuleImport> imports = Collections.emptySet();\r
 518         private Set<FeatureDefinition> features = Collections.emptySet();\r
 519         private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();\r
 520         private Set<NotificationDefinition> notifications = Collections.emptySet();\r
 521         private Set<AugmentationSchema> augmentations = Collections.emptySet();\r
 522         private Set<RpcDefinition> rpcs = Collections.emptySet();\r
 523         private Set<Deviation> deviations = Collections.emptySet();\r
 524         private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();\r
 525         private Set<GroupingDefinition> groupings = Collections.emptySet();\r
 526         private Set<UsesNode> uses = Collections.emptySet();\r
 527         private List<ExtensionDefinition> extensionSchemaNodes = Collections.emptyList();\r
 528         private Set<IdentitySchemaNode> identities = Collections.emptySet();\r
 529 \r
 530         private ModuleImpl(String name) {\r
 531             this.name = name;\r
 532         }\r
 533 \r
 534         @Override\r
 535         public URI getNamespace() {\r
 536             return namespace;\r
 537         }\r
 538 \r
 539         private void setNamespace(URI namespace) {\r
 540             this.namespace = namespace;\r
 541         }\r
 542 \r
 543         @Override\r
 544         public String getName() {\r
 545             return name;\r
 546         }\r
 547 \r
 548         @Override\r
 549         public Date getRevision() {\r
 550             return revision;\r
 551         }\r
 552 \r
 553         private void setRevision(Date revision) {\r
 554             this.revision = revision;\r
 555         }\r
 556 \r
 557         @Override\r
 558         public String getPrefix() {\r
 559             return prefix;\r
 560         }\r
 561 \r
 562         private void setPrefix(String prefix) {\r
 563             this.prefix = prefix;\r
 564         }\r
 565 \r
 566         @Override\r
 567         public String getYangVersion() {\r
 568             return yangVersion;\r
 569         }\r
 570 \r
 571         private void setYangVersion(String yangVersion) {\r
 572             this.yangVersion = yangVersion;\r
 573         }\r
 574 \r
 575         @Override\r
 576         public String getDescription() {\r
 577             return description;\r
 578         }\r
 579 \r
 580         private void setDescription(String description) {\r
 581             this.description = description;\r
 582         }\r
 583 \r
 584         @Override\r
 585         public String getReference() {\r
 586             return reference;\r
 587         }\r
 588 \r
 589         private void setReference(String reference) {\r
 590             this.reference = reference;\r
 591         }\r
 592 \r
 593         @Override\r
 594         public String getOrganization() {\r
 595             return organization;\r
 596         }\r
 597 \r
 598         private void setOrganization(String organization) {\r
 599             this.organization = organization;\r
 600         }\r
 601 \r
 602         @Override\r
 603         public String getContact() {\r
 604             return contact;\r
 605         }\r
 606 \r
 607         private void setContact(String contact) {\r
 608             this.contact = contact;\r
 609         }\r
 610 \r
 611         @Override\r
 612         public Set<ModuleImport> getImports() {\r
 613             return imports;\r
 614         }\r
 615 \r
 616         private void setImports(Set<ModuleImport> imports) {\r
 617             if(imports != null) {\r
 618                 this.imports = imports;\r
 619             }\r
 620         }\r
 621 \r
 622         @Override\r
 623         public Set<FeatureDefinition> getFeatures() {\r
 624             return features;\r
 625         }\r
 626 \r
 627         private void setFeatures(Set<FeatureDefinition> features) {\r
 628             if(features != null) {\r
 629                 this.features = features;\r
 630             }\r
 631         }\r
 632 \r
 633         @Override\r
 634         public Set<TypeDefinition<?>> getTypeDefinitions() {\r
 635             return typeDefinitions;\r
 636         }\r
 637 \r
 638         private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {\r
 639             if(typeDefinitions != null) {\r
 640                 this.typeDefinitions = typeDefinitions;\r
 641             }\r
 642         }\r
 643 \r
 644         @Override\r
 645         public Set<NotificationDefinition> getNotifications() {\r
 646             return notifications;\r
 647         }\r
 648 \r
 649         private void setNotifications(Set<NotificationDefinition> notifications) {\r
 650             if(notifications != null) {\r
 651                 this.notifications = notifications;\r
 652             }\r
 653         }\r
 654 \r
 655         @Override\r
 656         public Set<AugmentationSchema> getAugmentations() {\r
 657             return augmentations;\r
 658         }\r
 659 \r
 660         private void setAugmentations(Set<AugmentationSchema> augmentations) {\r
 661             if(augmentations != null) {\r
 662                 this.augmentations = augmentations;\r
 663             }\r
 664         }\r
 665 \r
 666         @Override\r
 667         public Set<RpcDefinition> getRpcs() {\r
 668             return rpcs;\r
 669         }\r
 670 \r
 671         private void setRpcs(Set<RpcDefinition> rpcs) {\r
 672             if(rpcs != null) {\r
 673                 this.rpcs = rpcs;\r
 674             }\r
 675         }\r
 676 \r
 677         @Override\r
 678         public Set<Deviation> getDeviations() {\r
 679             return deviations;\r
 680         }\r
 681 \r
 682         private void setDeviations(Set<Deviation> deviations) {\r
 683             if(deviations != null) {\r
 684                 this.deviations = deviations;\r
 685             }\r
 686         }\r
 687 \r
 688         @Override\r
 689         public Set<DataSchemaNode> getChildNodes() {\r
 690             return new HashSet<DataSchemaNode>(childNodes.values());\r
 691         }\r
 692 \r
 693         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {\r
 694             if(childNodes != null) {\r
 695                 this.childNodes = childNodes;\r
 696             }\r
 697         }\r
 698 \r
 699         @Override\r
 700         public Set<GroupingDefinition> getGroupings() {\r
 701             return groupings;\r
 702         }\r
 703 \r
 704         private void setGroupings(Set<GroupingDefinition> groupings) {\r
 705             if(groupings != null) {\r
 706                 this.groupings = groupings;\r
 707             }\r
 708         }\r
 709 \r
 710         @Override\r
 711         public Set<UsesNode> getUses() {\r
 712             return uses;\r
 713         }\r
 714 \r
 715         private void setUses(Set<UsesNode> uses) {\r
 716             if(uses != null) {\r
 717                 this.uses = uses;\r
 718             }\r
 719         }\r
 720 \r
 721         @Override\r
 722         public List<ExtensionDefinition> getExtensionSchemaNodes() {\r
 723             return extensionSchemaNodes;\r
 724         }\r
 725 \r
 726         private void setExtensionSchemaNodes(List<ExtensionDefinition> extensionSchemaNodes) {\r
 727             if(extensionSchemaNodes != null) {\r
 728                 this.extensionSchemaNodes = extensionSchemaNodes;\r
 729             }\r
 730         }\r
 731 \r
 732         @Override\r
 733         public Set<IdentitySchemaNode> getIdentities() {\r
 734             return identities;\r
 735         }\r
 736 \r
 737         private void setIdentities(Set<IdentitySchemaNode> identities) {\r
 738             if(identities != null) {\r
 739                 this.identities = identities;\r
 740             }\r
 741         }\r
 742 \r
 743         @Override\r
 744         public DataSchemaNode getDataChildByName(QName name) {\r
 745             return childNodes.get(name);\r
 746         }\r
 747 \r
 748         @Override\r
 749         public DataSchemaNode getDataChildByName(String name) {\r
 750             DataSchemaNode result = null;\r
 751             for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {\r
 752                 if (entry.getKey().getLocalName().equals(name)) {\r
 753                     result = entry.getValue();\r
 754                     break;\r
 755                 }\r
 756             }\r
 757             return result;\r
 758         }\r
 759 \r
 760         @Override\r
 761         public int hashCode() {\r
 762             final int prime = 31;\r
 763             int result = 1;\r
 764             result = prime * result + ((namespace == null) ? 0 : namespace.hashCode());\r
 765             result = prime * result + ((name == null) ? 0 : name.hashCode());\r
 766             result = prime * result + ((revision == null) ? 0 : revision.hashCode());\r
 767             result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());\r
 768             result = prime * result + ((yangVersion == null) ? 0 : yangVersion.hashCode());\r
 769             return result;\r
 770         }\r
 771 \r
 772         @Override\r
 773         public boolean equals(Object obj) {\r
 774             if (this == obj) {\r
 775                 return true;\r
 776             }\r
 777             if (obj == null) {\r
 778                 return false;\r
 779             }\r
 780             if (getClass() != obj.getClass()) {\r
 781                 return false;\r
 782             }\r
 783             ModuleImpl other = (ModuleImpl) obj;\r
 784             if (namespace == null) {\r
 785                 if (other.namespace != null) {\r
 786                     return false;\r
 787                 }\r
 788             } else if (!namespace.equals(other.namespace)) {\r
 789                 return false;\r
 790             }\r
 791             if (name == null) {\r
 792                 if (other.name != null) {\r
 793                     return false;\r
 794                 }\r
 795             } else if (!name.equals(other.name)) {\r
 796                 return false;\r
 797             }\r
 798             if (revision == null) {\r
 799                 if (other.revision != null) {\r
 800                     return false;\r
 801                 }\r
 802             } else if (!revision.equals(other.revision)) {\r
 803                 return false;\r
 804             }\r
 805             if (prefix == null) {\r
 806                 if (other.prefix != null) {\r
 807                     return false;\r
 808                 }\r
 809             } else if (!prefix.equals(other.prefix)) {\r
 810                 return false;\r
 811             }\r
 812             if (yangVersion == null) {\r
 813                 if (other.yangVersion != null) {\r
 814                     return false;\r
 815                 }\r
 816             } else if (!yangVersion.equals(other.yangVersion)) {\r
 817                 return false;\r
 818             }\r
 819             return true;\r
 820         }\r
 821 \r
 822         @Override\r
 823         public String toString() {\r
 824             StringBuilder sb = new StringBuilder(\r
 825                     ModuleImpl.class.getSimpleName());\r
 826             sb.append("[\n");\r
 827             sb.append("name=" + name + ",\n");\r
 828             sb.append("namespace=" + namespace + ",\n");\r
 829             sb.append("revision=" + revision + ",\n");\r
 830             sb.append("prefix=" + prefix + ",\n");\r
 831             sb.append("yangVersion=" + yangVersion + ",\n");\r
 832             sb.append("description=" + description + ",\n");\r
 833             sb.append("reference=" + reference + ",\n");\r
 834             sb.append("organization=" + organization + ",\n");\r
 835             sb.append("contact=" + contact + ",\n");\r
 836             sb.append("childNodes=" + childNodes.values() + ",\n");\r
 837             sb.append("groupings=" + groupings + ",\n");\r
 838             sb.append("imports=" + imports + ",\n");\r
 839             sb.append("features=" + features + ",\n");\r
 840             sb.append("typeDefinitions=" + typeDefinitions + ",\n");\r
 841             sb.append("notifications=" + notifications + ",\n");\r
 842             sb.append("augmentations=" + augmentations + ",\n");\r
 843             sb.append("rpcs=" + rpcs + ",\n");\r
 844             sb.append("deviations=" + deviations + "\n");\r
 845             sb.append("uses=" + uses + "\n");\r
 846             sb.append("]");\r
 847             return sb.toString();\r
 848         }\r
 849     }\r
 850 \r
 851     private ModuleImport createModuleImport(final String moduleName,\r
 852             final Date revision, final String prefix) {\r
 853         ModuleImport moduleImport = new ModuleImport() {\r
 854             @Override\r
 855             public String getModuleName() {\r
 856                 return moduleName;\r
 857             }\r
 858 \r
 859             @Override\r
 860             public Date getRevision() {\r
 861                 return revision;\r
 862             }\r
 863 \r
 864             @Override\r
 865             public String getPrefix() {\r
 866                 return prefix;\r
 867             }\r
 868 \r
 869             @Override\r
 870             public int hashCode() {\r
 871                 final int prime = 31;\r
 872                 int result = 1;\r
 873                 result = prime * result\r
 874                         + ((moduleName == null) ? 0 : moduleName.hashCode());\r
 875                 result = prime * result\r
 876                         + ((revision == null) ? 0 : revision.hashCode());\r
 877                 result = prime * result\r
 878                         + ((prefix == null) ? 0 : prefix.hashCode());\r
 879                 return result;\r
 880             }\r
 881 \r
 882             @Override\r
 883             public boolean equals(Object obj) {\r
 884                 if (this == obj) {\r
 885                     return true;\r
 886                 }\r
 887                 if (obj == null) {\r
 888                     return false;\r
 889                 }\r
 890                 if (getClass() != obj.getClass()) {\r
 891                     return false;\r
 892                 }\r
 893                 ModuleImport other = (ModuleImport) obj;\r
 894                 if (getModuleName() == null) {\r
 895                     if (other.getModuleName() != null) {\r
 896                         return false;\r
 897                     }\r
 898                 } else if (!getModuleName().equals(other.getModuleName())) {\r
 899                     return false;\r
 900                 }\r
 901                 if (getRevision() == null) {\r
 902                     if (other.getRevision() != null) {\r
 903                         return false;\r
 904                     }\r
 905                 } else if (!getRevision().equals(other.getRevision())) {\r
 906                     return false;\r
 907                 }\r
 908                 if (getPrefix() == null) {\r
 909                     if (other.getPrefix() != null) {\r
 910                         return false;\r
 911                     }\r
 912                 } else if (!getPrefix().equals(other.getPrefix())) {\r
 913                     return false;\r
 914                 }\r
 915                 return true;\r
 916             }\r
 917 \r
 918             @Override\r
 919             public String toString() {\r
 920                 return "ModuleImport[moduleName=" + moduleName + ", revision="\r
 921                         + revision + ", prefix=" + prefix + "]";\r
 922             }\r
 923         };\r
 924         return moduleImport;\r
 925     }\r
 926 \r
 927     /**\r
 928      * Traverse through given addedChilds and add only direct module childs.\r
 929      * Direct module child path size is 2 (1. module name, 2. child name).\r
 930      *\r
 931      * @param addedChilds\r
 932      * @return map of children, where key is child QName and value is child\r
 933      *         itself\r
 934      */\r
 935     private Map<QName, DataSchemaNode> buildModuleChildNodes(\r
 936             Map<List<String>, DataSchemaNodeBuilder> addedChilds) {\r
 937         final Map<QName, DataSchemaNode> childNodes = new HashMap<QName, DataSchemaNode>();\r
 938         for (Map.Entry<List<String>, DataSchemaNodeBuilder> entry : addedChilds\r
 939                 .entrySet()) {\r
 940             if (entry.getKey().size() == 2) {\r
 941                 DataSchemaNode node = entry.getValue().build();\r
 942                 QName qname = entry.getValue().getQName();\r
 943                 childNodes.put(qname, node);\r
 944             }\r
 945         }\r
 946         return childNodes;\r
 947     }\r
 948 \r
 949     /**\r
 950      * Traverse through given addedGroupings and add only direct module\r
 951      * groupings. Direct module grouping path size is 2 (1. module name, 2.\r
 952      * grouping name).\r
 953      *\r
 954      * @param addedGroupings\r
 955      * @return set of built GroupingDefinition objects\r
 956      */\r
 957     private Set<GroupingDefinition> buildModuleGroupings(\r
 958             Map<List<String>, GroupingBuilder> addedGroupings) {\r
 959         final Set<GroupingDefinition> groupings = new HashSet<GroupingDefinition>();\r
 960         for (Map.Entry<List<String>, GroupingBuilder> entry : addedGroupings\r
 961                 .entrySet()) {\r
 962             if (entry.getKey().size() == 2) {\r
 963                 groupings.add(entry.getValue().build());\r
 964             }\r
 965         }\r
 966         return groupings;\r
 967     }\r
 968 \r
 969     /**\r
 970      * Traverse through given addedRpcs and build RpcDefinition objects.\r
 971      *\r
 972      * @param addedRpcs\r
 973      * @return set of built RpcDefinition objects\r
 974      */\r
 975     private Set<RpcDefinition> buildModuleRpcs(\r
 976             Map<List<String>, RpcDefinitionBuilder> addedRpcs) {\r
 977         final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();\r
 978         RpcDefinitionBuilder builder;\r
 979         for (Map.Entry<List<String>, RpcDefinitionBuilder> entry : addedRpcs\r
 980                 .entrySet()) {\r
 981             builder = entry.getValue();\r
 982             RpcDefinition rpc = builder.build();\r
 983             rpcs.add(rpc);\r
 984         }\r
 985         return rpcs;\r
 986     }\r
 987 \r
 988     /**\r
 989      * Traverse through given addedTypedefs and add only direct module typedef\r
 990      * statements. Direct module typedef path size is 2 (1. module name, 2.\r
 991      * typedef name).\r
 992      *\r
 993      * @param addedTypedefs\r
 994      * @return set of built module typedef statements\r
 995      */\r
 996     private Set<TypeDefinition<?>> buildModuleTypedefs(\r
 997             Map<List<String>, TypeDefinitionBuilder> addedTypedefs) {\r
 998         Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();\r
 999         for (Map.Entry<List<String>, TypeDefinitionBuilder> entry : addedTypedefs\r
1000                 .entrySet()) {\r
1001             if (entry.getKey().size() == 2) {\r
1002                 TypeDefinition<? extends TypeDefinition<?>> node = entry\r
1003                         .getValue().build();\r
1004                 typedefs.add(node);\r
1005             }\r
1006         }\r
1007         return typedefs;\r
1008     }\r
1009 \r
1010     /**\r
1011      * Traverse through given addedUsesNodes and add only direct module uses\r
1012      * nodes. Direct module uses node path size is 2 (1. module name, 2. uses\r
1013      * name).\r
1014      *\r
1015      * @param addedUsesNodes\r
1016      * @return set of built module uses nodes\r
1017      */\r
1018     private Set<UsesNode> buildUsesNodes(\r
1019             Map<List<String>, UsesNodeBuilder> addedUsesNodes) {\r
1020         final Set<UsesNode> usesNodeDefinitions = new HashSet<UsesNode>();\r
1021         for (Map.Entry<List<String>, UsesNodeBuilder> entry : addedUsesNodes\r
1022                 .entrySet()) {\r
1023             if (entry.getKey().size() == 2) {\r
1024                 usesNodeDefinitions.add(entry.getValue().build());\r
1025             }\r
1026         }\r
1027         return usesNodeDefinitions;\r
1028     }\r
1029 \r
1030     /**\r
1031      * Traverse through given addedFeatures and add only direct module features.\r
1032      * Direct module feature path size is 2 (1. module name, 2. feature name).\r
1033      *\r
1034      * @param addedFeatures\r
1035      * @return set of built module features\r
1036      */\r
1037     private Set<FeatureDefinition> buildModuleFeatures(\r
1038             Map<List<String>, FeatureBuilder> addedFeatures) {\r
1039         Set<FeatureDefinition> features = new HashSet<FeatureDefinition>();\r
1040         for (Map.Entry<List<String>, FeatureBuilder> entry : addedFeatures\r
1041                 .entrySet()) {\r
1042             if (entry.getKey().size() == 2) {\r
1043                 features.add(entry.getValue().build());\r
1044             }\r
1045         }\r
1046         return features;\r
1047     }\r
1048 \r
1049 }\r