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