2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
\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
8 package org.opendaylight.controller.model.parser.builder;
\r
10 import java.net.URI;
\r
11 import java.util.ArrayList;
\r
12 import java.util.Date;
\r
13 import java.util.HashMap;
\r
14 import java.util.HashSet;
\r
15 import java.util.List;
\r
16 import java.util.Map;
\r
17 import java.util.Set;
\r
18 import java.util.Stack;
\r
20 import org.opendaylight.controller.model.parser.api.AugmentationSchemaBuilder;
\r
21 import org.opendaylight.controller.model.parser.api.Builder;
\r
22 import org.opendaylight.controller.model.parser.api.ChildNodeBuilder;
\r
23 import org.opendaylight.controller.model.parser.api.DataSchemaNodeBuilder;
\r
24 import org.opendaylight.controller.model.parser.api.GroupingBuilder;
\r
25 import org.opendaylight.controller.model.parser.api.TypeAwareBuilder;
\r
26 import org.opendaylight.controller.model.parser.api.TypeDefinitionAwareBuilder;
\r
27 import org.opendaylight.controller.model.parser.api.TypeDefinitionBuilder;
\r
28 import org.opendaylight.controller.model.parser.api.UsesNodeBuilder;
\r
29 import org.opendaylight.controller.yang.common.QName;
\r
30 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
\r
31 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
\r
32 import org.opendaylight.controller.yang.model.api.Deviation;
\r
33 import org.opendaylight.controller.yang.model.api.FeatureDefinition;
\r
34 import org.opendaylight.controller.yang.model.api.GroupingDefinition;
\r
35 import org.opendaylight.controller.yang.model.api.Module;
\r
36 import org.opendaylight.controller.yang.model.api.ModuleImport;
\r
37 import org.opendaylight.controller.yang.model.api.NotificationDefinition;
\r
38 import org.opendaylight.controller.yang.model.api.RpcDefinition;
\r
39 import org.opendaylight.controller.yang.model.api.TypeDefinition;
\r
40 import org.opendaylight.controller.yang.model.api.UsesNode;
\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
48 public class ModuleBuilder implements Builder {
\r
50 private final ModuleImpl instance;
\r
51 private final String name;
\r
52 private String prefix;
\r
54 private final Set<ModuleImport> imports = new HashSet<ModuleImport>();
\r
55 private Set<AugmentationSchema> augmentations;
\r
58 * All nodes, that can contain other nodes
\r
60 private final Map<List<String>, Builder> moduleNodes = new HashMap<List<String>, Builder>();
\r
63 * Holds all child (DataSchemaNode) nodes: anyxml, choice, container, list, leaf, leaf-list.
\r
65 private final Map<List<String>, DataSchemaNodeBuilder> addedChilds = new HashMap<List<String>, DataSchemaNodeBuilder>();
\r
67 private final Map<List<String>, GroupingBuilder> addedGroupings = new HashMap<List<String>, GroupingBuilder>();
\r
68 private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();
\r
69 private final Map<List<String>, UsesNodeBuilder> addedUsesNodes = new HashMap<List<String>, UsesNodeBuilder>();
\r
70 private final Map<List<String>, RpcDefinitionBuilder> addedRpcs = new HashMap<List<String>, RpcDefinitionBuilder>();
\r
71 private final Set<NotificationBuilder> addedNotifications = new HashSet<NotificationBuilder>();
\r
72 private final Map<List<String>, FeatureBuilder> addedFeatures = new HashMap<List<String>, FeatureBuilder>();
\r
73 private final Map<String, DeviationBuilder> addedDeviations = new HashMap<String, DeviationBuilder>();
\r
74 private final Map<List<String>, TypeDefinitionBuilder> addedTypedefs = new HashMap<List<String>, TypeDefinitionBuilder>();
\r
77 private final Map<List<String>, TypeAwareBuilder> dirtyNodes = new HashMap<List<String>, TypeAwareBuilder>();
\r
80 public ModuleBuilder(String name) {
\r
82 instance = new ModuleImpl(name);
\r
86 * Build new Module object based on this builder. Throws IllegalStateException if builder contains unresolved nodes.
\r
88 public Module build() {
\r
89 instance.setImports(imports);
\r
92 Set<TypeDefinition<?>> typedefs = buildModuleTypedefs(addedTypedefs);
\r
93 instance.setTypeDefinitions(typedefs);
\r
96 final Map<QName, DataSchemaNode> childNodes = buildModuleChildNodes(addedChilds);
\r
97 instance.setChildNodes(childNodes);
\r
100 final Set<GroupingDefinition> groupings = buildModuleGroupings(addedGroupings);
\r
101 instance.setGroupings(groupings);
\r
104 final Set<UsesNode> usesNodeDefinitions = buildUsesNodes(addedUsesNodes);
\r
105 instance.setUses(usesNodeDefinitions);
\r
108 Set<FeatureDefinition> features = buildModuleFeatures(addedFeatures);
\r
109 instance.setFeatures(features);
\r
112 final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();
\r
113 for (NotificationBuilder entry : addedNotifications) {
\r
114 notifications.add((NotificationDefinition) entry.build());
\r
116 instance.setNotifications(notifications);
\r
119 // final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
\r
120 // for(AugmentationSchemaBuilder entry : addedAugments) {
\r
121 // augmentations.add(entry.build());
\r
123 // instance.setAugmentations(augmentations);
\r
124 instance.setAugmentations(augmentations);
\r
127 final Set<RpcDefinition> rpcs = buildModuleRpcs(addedRpcs);
\r
128 instance.setRpcs(rpcs);
\r
131 Set<Deviation> deviations = new HashSet<Deviation>();
\r
132 for(Map.Entry<String, DeviationBuilder> entry : addedDeviations.entrySet()) {
\r
133 deviations.add(entry.getValue().build());
\r
135 instance.setDeviations(deviations);
\r
140 Builder getNode(List<String> path) {
\r
141 return moduleNodes.get(path);
\r
144 Map<List<String>, TypeAwareBuilder> getDirtyNodes() {
\r
152 String getPrefix() {
\r
156 Set<AugmentationSchemaBuilder> getAddedAugments() {
\r
157 return addedAugments;
\r
161 public void addDirtyNode(Stack<String> path) {
\r
162 List<String> dirtyNodePath = new ArrayList<String>(path);
\r
163 TypeAwareBuilder nodeBuilder = (TypeAwareBuilder)moduleNodes.get(dirtyNodePath);
\r
164 dirtyNodes.put(dirtyNodePath, nodeBuilder);
\r
167 public void setNamespace(URI namespace) {
\r
168 instance.setNamespace(namespace);
\r
171 public void setRevision(Date revision) {
\r
172 instance.setRevision(revision);
\r
175 public void setPrefix(String prefix) {
\r
176 this.prefix = prefix;
\r
177 instance.setPrefix(prefix);
\r
180 public void setYangVersion(String yangVersion) {
\r
181 instance.setYangVersion(yangVersion);
\r
184 public void setDescription(String description) {
\r
185 instance.setDescription(description);
\r
187 public void setReference(String reference) {
\r
188 instance.setReference(reference);
\r
190 public void setOrganization(String organization) {
\r
191 instance.setOrganization(organization);
\r
193 public void setContact(String contact) {
\r
194 instance.setContact(contact);
\r
196 public void setAugmentations(Set<AugmentationSchema> augmentations) {
\r
197 this.augmentations = augmentations;
\r
200 public boolean addModuleImport(final String moduleName, final Date revision, final String prefix) {
\r
201 ModuleImport moduleImport = createModuleImport(moduleName, revision, prefix);
\r
202 return imports.add(moduleImport);
\r
205 public Set<ModuleImport> getModuleImports() {
\r
209 public ContainerSchemaNodeBuilder addContainerNode(QName containerName, Stack<String> parentPath) {
\r
210 List<String> pathToNode = new ArrayList<String>(parentPath);
\r
212 ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(containerName);
\r
214 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);
\r
215 if(parent != null) {
\r
216 parent.addChildNode(containerBuilder);
\r
219 pathToNode.add(containerName.getLocalName());
\r
220 moduleNodes.put(pathToNode, containerBuilder);
\r
221 addedChilds.put(pathToNode, containerBuilder);
\r
223 return containerBuilder;
\r
226 public ListSchemaNodeBuilder addListNode(QName listName, Stack<String> parentPath) {
\r
227 List<String> pathToNode = new ArrayList<String>(parentPath);
\r
229 ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(listName);
\r
231 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);
\r
232 if(parent != null) {
\r
233 parent.addChildNode(listBuilder);
\r
236 pathToNode.add(listName.getLocalName());
\r
237 moduleNodes.put(pathToNode, listBuilder);
\r
238 addedChilds.put(pathToNode, listBuilder);
\r
240 return listBuilder;
\r
243 public LeafSchemaNodeBuilder addLeafNode(QName leafName, Stack<String> parentPath) {
\r
244 List<String> pathToNode = new ArrayList<String>(parentPath);
\r
246 LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(leafName);
\r
248 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);
\r
249 if(parent != null) {
\r
250 parent.addChildNode(leafBuilder);
\r
253 pathToNode.add(leafName.getLocalName());
\r
254 addedChilds.put(pathToNode, leafBuilder);
\r
255 moduleNodes.put(pathToNode, leafBuilder);
\r
257 return leafBuilder;
\r
260 public LeafListSchemaNodeBuilder addLeafListNode(QName leafListName, Stack<String> parentPath) {
\r
261 List<String> pathToNode = new ArrayList<String>(parentPath);
\r
263 LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(leafListName);
\r
264 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToNode);
\r
265 if(parent != null) {
\r
266 parent.addChildNode(leafListBuilder);
\r
269 pathToNode.add(leafListName.getLocalName());
\r
270 addedChilds.put(pathToNode, leafListBuilder);
\r
271 moduleNodes.put(pathToNode, leafListBuilder);
\r
273 return leafListBuilder;
\r
276 public GroupingBuilder addGrouping(QName qname, Stack<String> parentPath) {
\r
277 List<String> pathToGroup = new ArrayList<String>(parentPath);
\r
279 GroupingBuilder builder = new GroupingBuilderImpl(qname);
\r
280 ChildNodeBuilder parentNodeBuilder = (ChildNodeBuilder)moduleNodes.get(pathToGroup);
\r
281 if(parentNodeBuilder != null) {
\r
282 parentNodeBuilder.addGrouping(builder);
\r
285 pathToGroup.add(qname.getLocalName());
\r
286 moduleNodes.put(pathToGroup, builder);
\r
287 addedGroupings.put(pathToGroup, builder);
\r
292 public AugmentationSchemaBuilder addAugment(String name, Stack<String> parentPath) {
\r
293 List<String> pathToAugment = new ArrayList<String>(parentPath);
\r
295 AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(name);
\r
297 // augment can only be in 'module' or 'uses' statement
\r
298 UsesNodeBuilder parent = addedUsesNodes.get(pathToAugment);
\r
299 if(parent != null) {
\r
300 parent.addAugment(builder);
\r
303 pathToAugment.add(name);
\r
304 moduleNodes.put(pathToAugment, builder);
\r
305 addedAugments.add(builder);
\r
310 public UsesNodeBuilder addUsesNode(String groupingPathStr, Stack<String> parentPath) {
\r
311 List<String> pathToUses = new ArrayList<String>(parentPath);
\r
313 UsesNodeBuilder builder = new UsesNodeBuilderImpl(groupingPathStr);
\r
315 ChildNodeBuilder parent = (ChildNodeBuilder)moduleNodes.get(pathToUses);
\r
316 if(parent != null) {
\r
317 parent.addUsesNode(builder);
\r
320 pathToUses.add(groupingPathStr);
\r
321 addedUsesNodes.put(pathToUses, builder);
\r
326 public RpcDefinitionBuilder addRpc(QName qname, Stack<String> parentPath) {
\r
327 List<String> pathToRpc = new ArrayList<String>(parentPath);
\r
329 RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(qname);
\r
331 pathToRpc.add(qname.getLocalName());
\r
332 addedRpcs.put(pathToRpc, rpcBuilder);
\r
334 QName inputQName = new QName(qname.getNamespace(), qname.getRevision(), qname.getPrefix(), "input");
\r
335 ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(inputQName);
\r
336 List<String> pathToInput = new ArrayList<String>(pathToRpc);
\r
337 pathToInput.add("input");
\r
338 moduleNodes.put(pathToInput, inputBuilder);
\r
339 rpcBuilder.setInput(inputBuilder);
\r
341 QName outputQName = new QName(qname.getNamespace(), qname.getRevision(), qname.getPrefix(), "output");
\r
342 ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(outputQName);
\r
343 List<String> pathToOutput = new ArrayList<String>(pathToRpc);
\r
344 pathToOutput.add("output");
\r
345 moduleNodes.put(pathToOutput, outputBuilder);
\r
346 rpcBuilder.setOutput(outputBuilder);
\r
351 public NotificationBuilder addNotification(QName notificationName, Stack<String> parentPath) {
\r
352 List<String> pathToNotification = new ArrayList<String>(parentPath);
\r
354 NotificationBuilder notificationBuilder = new NotificationBuilder(notificationName);
\r
356 pathToNotification.add(notificationName.getLocalName());
\r
357 moduleNodes.put(pathToNotification, notificationBuilder);
\r
358 addedNotifications.add(notificationBuilder);
\r
360 return notificationBuilder;
\r
363 public FeatureBuilder addFeature(QName featureName, Stack<String> parentPath) {
\r
364 List<String> pathToFeature = new ArrayList<String>(parentPath);
\r
365 pathToFeature.add(featureName.getLocalName());
\r
367 FeatureBuilder builder = new FeatureBuilder(featureName);
\r
368 addedFeatures.put(pathToFeature, builder);
\r
372 public TypedefBuilder addTypedef(QName typeDefName, Stack<String> parentPath) {
\r
373 List<String> pathToType = new ArrayList<String>(parentPath);
\r
374 TypedefBuilder builder = new TypedefBuilder(typeDefName);
\r
375 TypeDefinitionAwareBuilder parent = (TypeDefinitionAwareBuilder)moduleNodes.get(pathToType);
\r
376 if(parent != null) {
\r
377 parent.addTypedef(builder);
\r
379 pathToType.add(typeDefName.getLocalName());
\r
380 addedTypedefs.put(pathToType, builder);
\r
381 moduleNodes.put(pathToType, builder);
\r
385 public Set<TypeDefinitionBuilder> getModuleTypedefs() {
\r
386 Set<TypeDefinitionBuilder> typedefs = new HashSet<TypeDefinitionBuilder>();
\r
387 for(Map.Entry<List<String>, TypeDefinitionBuilder> entry : addedTypedefs.entrySet()) {
\r
388 if(entry.getKey().size() == 2) {
\r
389 typedefs.add(entry.getValue());
\r
395 public void setType(TypeDefinition<?> type, Stack<String> parentPath) {
\r
396 TypeAwareBuilder parent = (TypeAwareBuilder)moduleNodes.get(parentPath);
\r
397 parent.setType(type);
\r
400 public DeviationBuilder addDeviation(String targetPath) {
\r
401 DeviationBuilder builder = new DeviationBuilder(targetPath);
\r
402 addedDeviations.put(targetPath, builder);
\r
406 public MustDefinitionBuilder addMustDefinition(String xpathStr, Stack<String> parentPath) {
\r
407 MustAwareBuilder parent = (MustAwareBuilder)moduleNodes.get(parentPath);
\r
408 String path = parentPath.get(parentPath.size()-1);
\r
409 if(parent == null) {
\r
410 for(Map.Entry<String, DeviationBuilder> db : addedDeviations.entrySet()) {
\r
411 String key = db.getKey();
\r
412 if(key.equals(path)) {
\r
413 parent = db.getValue();
\r
417 MustDefinitionBuilder builder = new MustDefinitionBuilder(xpathStr);
\r
418 parent.setMustDefinitionBuilder(builder);
\r
422 public ModuleBuilder addSubmodule(QName qname) {
\r
423 ModuleBuilder submoduleBuilder = new ModuleBuilder(qname.getLocalName());
\r
424 return submoduleBuilder;
\r
429 private class ModuleImpl implements Module {
\r
431 private URI namespace;
\r
432 private final String name;
\r
433 private Date revision;
\r
434 private String prefix;
\r
435 private String yangVersion;
\r
436 private String description;
\r
437 private String reference;
\r
438 private String organization;
\r
439 private String contact;
\r
440 private Set<ModuleImport> imports;
\r
441 private Set<FeatureDefinition> features;
\r
442 private Set<TypeDefinition<?>> typeDefinitions;
\r
443 private Set<NotificationDefinition> notifications;
\r
444 private Set<AugmentationSchema> augmentations;
\r
445 private Set<RpcDefinition> rpcs;
\r
446 private Set<Deviation> deviations;
\r
447 private Map<QName, DataSchemaNode> childNodes;
\r
448 private Set<GroupingDefinition> groupings;
\r
449 private Set<UsesNode> uses;
\r
451 private ModuleImpl(String name) {
\r
457 public URI getNamespace() {
\r
460 private void setNamespace(URI namespace) {
\r
461 this.namespace = namespace;
\r
465 public String getName() {
\r
470 public Date getRevision() {
\r
473 private void setRevision(Date revision) {
\r
474 this.revision = revision;
\r
478 public String getPrefix() {
\r
481 private void setPrefix(String prefix) {
\r
482 this.prefix = prefix;
\r
486 public String getYangVersion() {
\r
487 return yangVersion;
\r
489 private void setYangVersion(String yangVersion) {
\r
490 this.yangVersion = yangVersion;
\r
494 public String getDescription() {
\r
495 return description;
\r
497 private void setDescription(String description) {
\r
498 this.description = description;
\r
502 public String getReference() {
\r
505 private void setReference(String reference) {
\r
506 this.reference = reference;
\r
510 public String getOrganization() {
\r
511 return organization;
\r
513 private void setOrganization(String organization) {
\r
514 this.organization = organization;
\r
518 public String getContact() {
\r
521 private void setContact(String contact) {
\r
522 this.contact = contact;
\r
526 public Set<ModuleImport> getImports() {
\r
529 private void setImports(Set<ModuleImport> imports) {
\r
530 this.imports = imports;
\r
534 public Set<FeatureDefinition> getFeatures() {
\r
537 private void setFeatures(Set<FeatureDefinition> features) {
\r
538 this.features = features;
\r
542 public Set<TypeDefinition<?>> getTypeDefinitions() {
\r
543 return typeDefinitions;
\r
545 private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
\r
546 this.typeDefinitions = typeDefinitions;
\r
550 public Set<NotificationDefinition> getNotifications() {
\r
551 return notifications;
\r
553 private void setNotifications(Set<NotificationDefinition> notifications) {
\r
554 this.notifications = notifications;
\r
558 public Set<AugmentationSchema> getAugmentations() {
\r
559 return augmentations;
\r
561 private void setAugmentations(Set<AugmentationSchema> augmentations) {
\r
562 this.augmentations = augmentations;
\r
566 public Set<RpcDefinition> getRpcs() {
\r
569 private void setRpcs(Set<RpcDefinition> rpcs) {
\r
574 public Set<Deviation> getDeviations() {
\r
577 private void setDeviations(Set<Deviation> deviations) {
\r
578 this.deviations = deviations;
\r
582 public Set<DataSchemaNode> getChildNodes() {
\r
583 return new HashSet<DataSchemaNode>(childNodes.values());
\r
585 private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
\r
586 this.childNodes = childNodes;
\r
590 public Set<GroupingDefinition> getGroupings() {
\r
593 private void setGroupings(Set<GroupingDefinition> groupings) {
\r
594 this.groupings = groupings;
\r
598 public Set<UsesNode> getUses() {
\r
601 private void setUses(Set<UsesNode> uses) {
\r
606 public DataSchemaNode getDataChildByName(QName name) {
\r
607 return childNodes.get(name);
\r
610 public DataSchemaNode getDataChildByName(String name) {
\r
611 DataSchemaNode result = null;
\r
612 for(Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
\r
613 if(entry.getKey().getLocalName().equals(name)) {
\r
614 result = entry.getValue();
\r
622 public String toString() {
\r
623 StringBuilder sb = new StringBuilder(ModuleImpl.class.getSimpleName());
\r
625 sb.append("name="+ name +",\n");
\r
626 sb.append("namespace="+ namespace +",\n");
\r
627 sb.append("revision="+ revision +",\n");
\r
628 sb.append("prefix="+ prefix +",\n");
\r
629 sb.append("yangVersion="+ yangVersion +",\n");
\r
630 sb.append("description="+ description +",\n");
\r
631 sb.append("reference="+ reference +",\n");
\r
632 sb.append("organization="+ organization +",\n");
\r
633 sb.append("contact="+ contact +",\n");
\r
634 sb.append("childNodes="+ childNodes.values() +",\n");
\r
635 sb.append("groupings="+ groupings +",\n");
\r
636 sb.append("imports="+ imports +",\n");
\r
637 sb.append("features="+ features +",\n");
\r
638 sb.append("typeDefinitions="+ typeDefinitions +",\n");
\r
639 sb.append("notifications="+ notifications +",\n");
\r
640 sb.append("augmentations="+ augmentations +",\n");
\r
641 sb.append("rpcs="+ rpcs +",\n");
\r
642 sb.append("deviations="+ deviations +"\n");
\r
644 return sb.toString();
\r
649 private ModuleImport createModuleImport(final String moduleName, final Date revision, final String prefix) {
\r
650 ModuleImport moduleImport = new ModuleImport() {
\r
652 public String getModuleName() {
\r
656 public Date getRevision() {
\r
660 public String getPrefix() {
\r
665 public int hashCode() {
\r
666 final int prime = 31;
\r
668 result = prime * result + ((moduleName == null) ? 0 : moduleName.hashCode());
\r
669 result = prime * result + ((revision == null) ? 0 : revision.hashCode());
\r
670 result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
\r
675 public boolean equals(Object obj) {
\r
682 if (getClass() != obj.getClass()) {
\r
685 ModuleImport other = (ModuleImport) obj;
\r
686 if (getModuleName() == null) {
\r
687 if (other.getModuleName() != null) {
\r
690 } else if (!getModuleName().equals(other.getModuleName())) {
\r
693 if (getRevision() == null) {
\r
694 if (other.getRevision() != null) {
\r
697 } else if (!getRevision().equals(other.getRevision())) {
\r
700 if (getPrefix() == null) {
\r
701 if (other.getPrefix() != null) {
\r
704 } else if (!getPrefix().equals(other.getPrefix())) {
\r
711 public String toString() {
\r
712 return "ModuleImport[moduleName="+ moduleName +", revision="+ revision +", prefix="+ prefix +"]";
\r
715 return moduleImport;
\r
719 * Traverse through given addedChilds and add only direct module childs. Direct
\r
720 * module child path size is 2 (1. module name, 2. child name).
\r
722 * @param addedChilds
\r
723 * @return map of children, where key is child QName and value is child itself
\r
725 private Map<QName, DataSchemaNode> buildModuleChildNodes(
\r
726 Map<List<String>, DataSchemaNodeBuilder> addedChilds) {
\r
727 final Map<QName, DataSchemaNode> childNodes = new HashMap<QName, DataSchemaNode>();
\r
728 for (Map.Entry<List<String>, DataSchemaNodeBuilder> entry : addedChilds
\r
730 if (entry.getKey().size() == 2) {
\r
731 DataSchemaNode node = entry.getValue().build();
\r
732 QName qname = entry.getValue().getQName();
\r
733 childNodes.put(qname, node);
\r
740 * Traverse through given addedGroupings and add only direct module groupings. Direct
\r
741 * module grouping path size is 2 (1. module name, 2. grouping name).
\r
743 * @param addedGroupings
\r
744 * @return set of built GroupingDefinition objects
\r
746 private Set<GroupingDefinition> buildModuleGroupings(Map<List<String>, GroupingBuilder> addedGroupings) {
\r
747 final Set<GroupingDefinition> groupings = new HashSet<GroupingDefinition>();
\r
748 for(Map.Entry<List<String>, GroupingBuilder> entry : addedGroupings.entrySet()) {
\r
749 if(entry.getKey().size() == 2) {
\r
750 groupings.add(entry.getValue().build());
\r
757 * Traverse through given addedRpcs and build RpcDefinition objects.
\r
759 * @return set of built RpcDefinition objects
\r
761 private Set<RpcDefinition> buildModuleRpcs(Map<List<String>, RpcDefinitionBuilder> addedRpcs) {
\r
762 final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();
\r
763 RpcDefinitionBuilder builder;
\r
764 for(Map.Entry<List<String>, RpcDefinitionBuilder> entry : addedRpcs.entrySet()) {
\r
765 builder = entry.getValue();
\r
766 RpcDefinition rpc = builder.build();
\r
773 * Traverse through given addedTypedefs and add only direct module typedef statements. Direct
\r
774 * module typedef path size is 2 (1. module name, 2. typedef name).
\r
776 * @param addedTypedefs
\r
777 * @return set of built module typedef statements
\r
779 private Set<TypeDefinition<?>> buildModuleTypedefs(Map<List<String>, TypeDefinitionBuilder> addedTypedefs) {
\r
780 Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
\r
781 for(Map.Entry<List<String>, TypeDefinitionBuilder> entry : addedTypedefs.entrySet()) {
\r
782 if(entry.getKey().size() == 2) {
\r
783 TypeDefinition<? extends TypeDefinition<?>> node = entry.getValue().build();
\r
784 typedefs.add(node);
\r
791 * Traverse through given addedUsesNodes and add only direct module uses nodes. Direct
\r
792 * module uses node path size is 2 (1. module name, 2. uses name).
\r
794 * @param addedUsesNodes
\r
795 * @return set of built module uses nodes
\r
797 private Set<UsesNode> buildUsesNodes(Map<List<String>, UsesNodeBuilder> addedUsesNodes) {
\r
798 final Set<UsesNode> usesNodeDefinitions = new HashSet<UsesNode>();
\r
799 for (Map.Entry<List<String>, UsesNodeBuilder> entry : addedUsesNodes.entrySet()) {
\r
800 if (entry.getKey().size() == 2) {
\r
801 usesNodeDefinitions.add(entry.getValue().build());
\r
804 return usesNodeDefinitions;
\r
808 * Traverse through given addedFeatures and add only direct module features. Direct
\r
809 * module feature path size is 2 (1. module name, 2. feature name).
\r
811 * @param addedFeatures
\r
812 * @return set of built module features
\r
814 private Set<FeatureDefinition> buildModuleFeatures(Map<List<String>, FeatureBuilder> addedFeatures) {
\r
815 Set<FeatureDefinition> features = new HashSet<FeatureDefinition>();
\r
816 for(Map.Entry<List<String>, FeatureBuilder> entry : addedFeatures.entrySet()) {
\r
817 if(entry.getKey().size() == 2) {
\r
818 features.add((FeatureDefinition)entry.getValue().build());
\r