2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.yang.parser.builder.impl;
10 import java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.HashSet;
13 import java.util.List;
16 import java.util.TreeMap;
17 import java.util.TreeSet;
19 import org.opendaylight.controller.yang.common.QName;
20 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
21 import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
22 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
23 import org.opendaylight.controller.yang.model.api.GroupingDefinition;
24 import org.opendaylight.controller.yang.model.api.ListSchemaNode;
25 import org.opendaylight.controller.yang.model.api.SchemaPath;
26 import org.opendaylight.controller.yang.model.api.Status;
27 import org.opendaylight.controller.yang.model.api.TypeDefinition;
28 import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
29 import org.opendaylight.controller.yang.model.api.UsesNode;
30 import org.opendaylight.controller.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
31 import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
32 import org.opendaylight.controller.yang.parser.builder.api.AugmentationTargetBuilder;
33 import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
34 import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
35 import org.opendaylight.controller.yang.parser.builder.api.GroupingMember;
36 import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
37 import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
38 import org.opendaylight.controller.yang.parser.util.Comparators;
40 public final class ListSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
41 AugmentationTargetBuilder, GroupingMember {
42 private boolean isBuilt;
43 private final ListSchemaNodeImpl instance;
45 private SchemaPath schemaPath;
46 private String description;
47 private String reference;
48 private Status status = Status.CURRENT;
49 // DataSchemaNode args
50 private boolean augmenting;
51 private boolean addedByUses;
52 private Boolean configuration;
53 private final ConstraintsBuilder constraints;
54 // DataNodeContainer args
55 private Set<TypeDefinition<?>> typedefs;
56 private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
57 private Set<UsesNode> usesNodes;
58 private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
59 // AugmentationTarget args
60 private Set<AugmentationSchema> augmentations;
61 private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
62 // ListSchemaNode args
63 private List<QName> keyDefinition = Collections.emptyList();
64 private boolean userOrdered;
66 public ListSchemaNodeBuilder(final int line, final QName qname, final SchemaPath schemaPath) {
68 this.schemaPath = schemaPath;
69 instance = new ListSchemaNodeImpl(qname);
70 constraints = new ConstraintsBuilder(line);
73 public ListSchemaNodeBuilder(final ListSchemaNodeBuilder b) {
74 super(b.getLine(), b.getQName());
75 instance = new ListSchemaNodeImpl(b.getQName());
76 constraints = b.getConstraints();
77 schemaPath = b.getPath();
78 description = b.getDescription();
79 reference = b.getReference();
80 status = b.getStatus();
81 augmenting = b.isAugmenting();
82 addedByUses = b.isAddedByUses();
83 configuration = b.isConfiguration();
84 keyDefinition = b.getKeyDefinition();
85 userOrdered = b.isUserOrdered();
86 childNodes = b.getChildNodes();
87 addedChildNodes.addAll(b.getChildNodeBuilders());
88 groupings = b.getGroupings();
89 addedGroupings.addAll(b.getGroupingBuilders());
90 typedefs = b.typedefs;
91 addedTypedefs.addAll(b.getTypeDefinitionBuilders());
92 usesNodes = b.usesNodes;
93 addedUsesNodes.addAll(b.getUsesNodes());
94 augmentations = b.augmentations;
95 addedAugmentations.addAll(b.getAugmentations());
96 unknownNodes = b.unknownNodes;
97 addedUnknownNodes.addAll(b.getUnknownNodeBuilders());
101 public ListSchemaNode build() {
103 instance.setKeyDefinition(keyDefinition);
104 instance.setPath(schemaPath);
105 instance.setDescription(description);
106 instance.setReference(reference);
107 instance.setStatus(status);
108 instance.setAugmenting(augmenting);
109 instance.setAddedByUses(addedByUses);
110 instance.setConfiguration(configuration);
111 instance.setUserOrdered(userOrdered);
114 final Map<QName, DataSchemaNode> childs = new TreeMap<QName, DataSchemaNode>(Comparators.QNAME_COMP);
115 if (childNodes == null) {
116 for (DataSchemaNodeBuilder node : addedChildNodes) {
117 childs.put(node.getQName(), node.build());
120 for (DataSchemaNode node : childNodes) {
121 childs.put(node.getQName(), node);
124 instance.setChildNodes(childs);
127 if (typedefs == null) {
128 typedefs = new TreeSet<TypeDefinition<?>>(Comparators.SCHEMA_NODE_COMP);
129 for (TypeDefinitionBuilder entry : addedTypedefs) {
130 typedefs.add(entry.build());
133 instance.setTypeDefinitions(typedefs);
136 if (usesNodes == null) {
137 usesNodes = new HashSet<UsesNode>();
138 for (UsesNodeBuilder builder : addedUsesNodes) {
139 usesNodes.add(builder.build());
142 instance.setUses(usesNodes);
145 if (groupings == null) {
146 groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);
147 for (GroupingBuilder builder : addedGroupings) {
148 groupings.add(builder.build());
151 instance.setGroupings(groupings);
154 if (augmentations == null) {
155 augmentations = new HashSet<AugmentationSchema>();
156 for (AugmentationSchemaBuilder builder : addedAugmentations) {
157 augmentations.add(builder.build());
160 instance.setAvailableAugmentations(augmentations);
163 if (unknownNodes == null) {
164 unknownNodes = new ArrayList<UnknownSchemaNode>();
165 for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
166 unknownNodes.add(b.build());
168 Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
170 instance.setUnknownSchemaNodes(unknownNodes);
172 instance.setConstraints(constraints.build());
173 instance.setAvailableAugmentations(augmentations);
181 public void rebuild() {
187 public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
188 return addedTypedefs;
192 public void addTypedef(final TypeDefinitionBuilder type) {
193 addedTypedefs.add(type);
196 public void setTypedefs(final Set<TypeDefinition<?>> typedefs) {
197 this.typedefs = typedefs;
200 public SchemaPath getPath() {
205 public void setPath(final SchemaPath schemaPath) {
206 this.schemaPath = schemaPath;
209 public String getDescription() {
214 public void setDescription(final String description) {
215 this.description = description;
218 public String getReference() {
223 public void setReference(String reference) {
224 this.reference = reference;
227 public Status getStatus() {
232 public void setStatus(Status status) {
233 if (status != null) {
234 this.status = status;
238 public Set<UsesNodeBuilder> getUsesNodes() {
239 return addedUsesNodes;
243 public void addUsesNode(final UsesNodeBuilder usesBuilder) {
244 addedUsesNodes.add(usesBuilder);
247 public void setUsesnodes(final Set<UsesNode> usesNodes) {
248 this.usesNodes = usesNodes;
251 public Set<AugmentationSchemaBuilder> getAugmentations() {
252 return addedAugmentations;
256 public void addAugmentation(AugmentationSchemaBuilder augment) {
257 addedAugmentations.add(augment);
260 public void setAugmentations(final Set<AugmentationSchema> augmentations) {
261 this.augmentations = augmentations;
264 public List<QName> getKeyDefinition() {
265 return keyDefinition;
268 public void setKeyDefinition(final List<QName> keyDefinition) {
269 if (keyDefinition != null) {
270 this.keyDefinition = keyDefinition;
274 public boolean isAugmenting() {
279 public void setAugmenting(boolean augmenting) {
280 this.augmenting = augmenting;
284 public boolean isAddedByUses() {
289 public void setAddedByUses(final boolean addedByUses) {
290 this.addedByUses = addedByUses;
293 public Boolean isConfiguration() {
294 return configuration;
298 public void setConfiguration(Boolean configuration) {
299 this.configuration = configuration;
303 public ConstraintsBuilder getConstraints() {
307 public boolean isUserOrdered() {
311 public void setUserOrdered(final boolean userOrdered) {
312 this.userOrdered = userOrdered;
316 public int hashCode() {
317 final int prime = 31;
319 result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
324 public boolean equals(Object obj) {
331 if (getClass() != obj.getClass()) {
334 ListSchemaNodeBuilder other = (ListSchemaNodeBuilder) obj;
335 if (schemaPath == null) {
336 if (other.schemaPath != null) {
339 } else if (!schemaPath.equals(other.schemaPath)) {
342 if (parent == null) {
343 if (other.parent != null) {
346 } else if (!parent.equals(other.parent)) {
353 public String toString() {
354 return "list " + qname.getLocalName();
357 public final class ListSchemaNodeImpl implements ListSchemaNode {
358 private final QName qname;
359 private SchemaPath path;
360 private String description;
361 private String reference;
362 private Status status = Status.CURRENT;
363 private List<QName> keyDefinition = Collections.emptyList();
364 private boolean augmenting;
365 private boolean addedByUses;
366 private boolean configuration;
367 private ConstraintDefinition constraints;
368 private Set<AugmentationSchema> augmentations = Collections.emptySet();
369 private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
370 private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
371 private Set<GroupingDefinition> groupings = Collections.emptySet();
372 private Set<UsesNode> uses = Collections.emptySet();
373 private boolean userOrdered;
374 private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
376 private ListSchemaNodeImpl(final QName qname) {
381 public QName getQName() {
386 public SchemaPath getPath() {
390 private void setPath(final SchemaPath path) {
395 public String getDescription() {
399 private void setDescription(final String description) {
400 this.description = description;
404 public String getReference() {
408 private void setReference(final String reference) {
409 this.reference = reference;
413 public Status getStatus() {
417 private void setStatus(Status status) {
418 this.status = status;
422 public List<QName> getKeyDefinition() {
423 return keyDefinition;
426 private void setKeyDefinition(List<QName> keyDefinition) {
427 if (keyDefinition != null) {
428 this.keyDefinition = keyDefinition;
433 public boolean isAugmenting() {
437 private void setAugmenting(boolean augmenting) {
438 this.augmenting = augmenting;
442 public boolean isAddedByUses() {
446 private void setAddedByUses(final boolean addedByUses) {
447 this.addedByUses = addedByUses;
451 public boolean isConfiguration() {
452 return configuration;
455 private void setConfiguration(boolean configuration) {
456 this.configuration = configuration;
460 public ConstraintDefinition getConstraints() {
464 private void setConstraints(ConstraintDefinition constraints) {
465 this.constraints = constraints;
469 public Set<AugmentationSchema> getAvailableAugmentations() {
470 return augmentations;
473 private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
474 if (augmentations != null) {
475 this.augmentations = augmentations;
480 public Set<DataSchemaNode> getChildNodes() {
481 return new HashSet<DataSchemaNode>(childNodes.values());
484 private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
485 if (childNodes != null) {
486 this.childNodes = childNodes;
491 public Set<GroupingDefinition> getGroupings() {
495 private void setGroupings(Set<GroupingDefinition> groupings) {
496 if (groupings != null) {
497 this.groupings = groupings;
502 public Set<TypeDefinition<?>> getTypeDefinitions() {
503 return typeDefinitions;
506 private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
507 if (typeDefinitions != null) {
508 this.typeDefinitions = typeDefinitions;
513 public Set<UsesNode> getUses() {
517 private void setUses(Set<UsesNode> uses) {
524 public DataSchemaNode getDataChildByName(QName name) {
525 return childNodes.get(name);
529 public DataSchemaNode getDataChildByName(String name) {
530 DataSchemaNode result = null;
531 for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
532 if (entry.getKey().getLocalName().equals(name)) {
533 result = entry.getValue();
541 public boolean isUserOrdered() {
545 private void setUserOrdered(boolean userOrdered) {
546 this.userOrdered = userOrdered;
550 public List<UnknownSchemaNode> getUnknownSchemaNodes() {
554 private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
555 if (unknownNodes != null) {
556 this.unknownNodes = unknownNodes;
560 public ListSchemaNodeBuilder toBuilder() {
561 return ListSchemaNodeBuilder.this;
565 public int hashCode() {
566 final int prime = 31;
568 result = prime * result + ((qname == null) ? 0 : qname.hashCode());
569 result = prime * result + ((path == null) ? 0 : path.hashCode());
574 public boolean equals(Object obj) {
581 if (getClass() != obj.getClass()) {
584 final ListSchemaNodeImpl other = (ListSchemaNodeImpl) obj;
586 if (other.qname != null) {
589 } else if (!qname.equals(other.qname)) {
593 if (other.path != null) {
596 } else if (!path.equals(other.path)) {
603 public String toString() {
604 StringBuilder sb = new StringBuilder(ListSchemaNodeImpl.class.getSimpleName());
606 sb.append("qname=" + qname);
607 sb.append(", path=" + path);
608 sb.append(", keyDefinition=" + keyDefinition);
610 return sb.toString();