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.yangtools.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.yangtools.yang.common.QName;
20 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
21 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
22 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
23 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
24 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
25 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
26 import org.opendaylight.yangtools.yang.model.api.Status;
27 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
28 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
29 import org.opendaylight.yangtools.yang.model.api.UsesNode;
30 import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
31 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
32 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
33 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
34 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
35 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember;
36 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
37 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
38 import org.opendaylight.yangtools.yang.parser.util.Comparators;
39 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
41 public final class ListSchemaNodeBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
42 AugmentationTargetBuilder, GroupingMember {
43 private boolean isBuilt;
44 private final ListSchemaNodeImpl instance;
46 private SchemaPath schemaPath;
47 private String description;
48 private String reference;
49 private Status status = Status.CURRENT;
50 // DataSchemaNode args
51 private boolean augmenting;
52 private boolean addedByUses;
53 private Boolean configuration;
54 private final ConstraintsBuilder constraints;
55 // DataNodeContainer args
56 private Set<TypeDefinition<?>> typedefs;
57 private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
58 private Set<UsesNode> usesNodes;
59 private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
60 // AugmentationTarget args
61 private Set<AugmentationSchema> augmentations;
62 private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
63 // ListSchemaNode args
64 private List<QName> keyDefinition = Collections.emptyList();
65 private boolean userOrdered;
67 public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath schemaPath) {
68 super(moduleName, line, qname);
69 this.schemaPath = schemaPath;
70 instance = new ListSchemaNodeImpl(qname);
71 constraints = new ConstraintsBuilder(moduleName, line);
75 public ListSchemaNode build() {
77 instance.setKeyDefinition(keyDefinition);
78 instance.setPath(schemaPath);
79 instance.setDescription(description);
80 instance.setReference(reference);
81 instance.setStatus(status);
82 instance.setAugmenting(augmenting);
83 instance.setAddedByUses(addedByUses);
84 instance.setConfiguration(configuration);
85 instance.setUserOrdered(userOrdered);
88 final Map<QName, DataSchemaNode> childs = new TreeMap<QName, DataSchemaNode>(Comparators.QNAME_COMP);
89 if (childNodes == null || childNodes.isEmpty()) {
90 for (DataSchemaNodeBuilder node : addedChildNodes) {
91 childs.put(node.getQName(), node.build());
94 for (DataSchemaNode node : childNodes) {
95 childs.put(node.getQName(), node);
98 instance.setChildNodes(childs);
101 if (typedefs == null) {
102 typedefs = new TreeSet<TypeDefinition<?>>(Comparators.SCHEMA_NODE_COMP);
103 for (TypeDefinitionBuilder entry : addedTypedefs) {
104 typedefs.add(entry.build());
107 instance.setTypeDefinitions(typedefs);
110 if (usesNodes == null) {
111 usesNodes = new HashSet<UsesNode>();
112 for (UsesNodeBuilder builder : addedUsesNodes) {
113 usesNodes.add(builder.build());
116 instance.setUses(usesNodes);
119 if (groupings == null) {
120 groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);
121 for (GroupingBuilder builder : addedGroupings) {
122 groupings.add(builder.build());
125 instance.setGroupings(groupings);
128 if (augmentations == null) {
129 augmentations = new HashSet<AugmentationSchema>();
130 for (AugmentationSchemaBuilder builder : addedAugmentations) {
131 augmentations.add(builder.build());
134 instance.setAvailableAugmentations(augmentations);
137 if (unknownNodes == null) {
138 unknownNodes = new ArrayList<UnknownSchemaNode>();
139 for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
140 unknownNodes.add(b.build());
142 Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
144 instance.setUnknownSchemaNodes(unknownNodes);
146 instance.setConstraints(constraints.build());
147 instance.setAvailableAugmentations(augmentations);
155 public void rebuild() {
161 public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
162 return addedTypedefs;
166 public void addTypedef(final TypeDefinitionBuilder type) {
167 String typeName = type.getQName().getLocalName();
168 for (TypeDefinitionBuilder addedTypedef : addedTypedefs) {
169 throw new YangParseException(moduleName, type.getLine(), "Can not add typedef '" + typeName
170 + "': typedef with same name already declared at line " + addedTypedef.getLine());
172 addedTypedefs.add(type);
175 public void setTypedefs(final Set<TypeDefinition<?>> typedefs) {
176 this.typedefs = typedefs;
179 public SchemaPath getPath() {
184 public void setPath(final SchemaPath schemaPath) {
185 this.schemaPath = schemaPath;
188 public String getDescription() {
193 public void setDescription(final String description) {
194 this.description = description;
197 public String getReference() {
202 public void setReference(String reference) {
203 this.reference = reference;
206 public Status getStatus() {
211 public void setStatus(Status status) {
212 if (status != null) {
213 this.status = status;
217 public Set<UsesNodeBuilder> getUsesNodes() {
218 return addedUsesNodes;
222 public void addUsesNode(final UsesNodeBuilder usesBuilder) {
223 addedUsesNodes.add(usesBuilder);
226 public void setUsesnodes(final Set<UsesNode> usesNodes) {
227 this.usesNodes = usesNodes;
230 public Set<AugmentationSchemaBuilder> getAugmentations() {
231 return addedAugmentations;
235 public void addAugmentation(AugmentationSchemaBuilder augment) {
236 addedAugmentations.add(augment);
239 public void setAugmentations(final Set<AugmentationSchema> augmentations) {
240 this.augmentations = augmentations;
243 public List<QName> getKeyDefinition() {
244 return keyDefinition;
247 public void setKeyDefinition(final List<QName> keyDefinition) {
248 if (keyDefinition != null) {
249 this.keyDefinition = keyDefinition;
253 public boolean isAugmenting() {
258 public void setAugmenting(boolean augmenting) {
259 this.augmenting = augmenting;
263 public boolean isAddedByUses() {
268 public void setAddedByUses(final boolean addedByUses) {
269 this.addedByUses = addedByUses;
272 public Boolean isConfiguration() {
273 return configuration;
277 public void setConfiguration(Boolean configuration) {
278 this.configuration = configuration;
282 public ConstraintsBuilder getConstraints() {
286 public boolean isUserOrdered() {
290 public void setUserOrdered(final boolean userOrdered) {
291 this.userOrdered = userOrdered;
295 public int hashCode() {
296 final int prime = 31;
298 result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
303 public boolean equals(Object obj) {
310 if (getClass() != obj.getClass()) {
313 ListSchemaNodeBuilder other = (ListSchemaNodeBuilder) obj;
314 if (schemaPath == null) {
315 if (other.schemaPath != null) {
318 } else if (!schemaPath.equals(other.schemaPath)) {
321 if (parent == null) {
322 if (other.parent != null) {
325 } else if (!parent.equals(other.parent)) {
332 public String toString() {
333 return "list " + qname.getLocalName();
336 public final class ListSchemaNodeImpl implements ListSchemaNode {
337 private final QName qname;
338 private SchemaPath path;
339 private String description;
340 private String reference;
341 private Status status = Status.CURRENT;
342 private List<QName> keyDefinition = Collections.emptyList();
343 private boolean augmenting;
344 private boolean addedByUses;
345 private boolean configuration;
346 private ConstraintDefinition constraints;
347 private Set<AugmentationSchema> augmentations = Collections.emptySet();
348 private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
349 private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
350 private Set<GroupingDefinition> groupings = Collections.emptySet();
351 private Set<UsesNode> uses = Collections.emptySet();
352 private boolean userOrdered;
353 private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
355 private ListSchemaNodeImpl(final QName qname) {
360 public QName getQName() {
365 public SchemaPath getPath() {
369 private void setPath(final SchemaPath path) {
374 public String getDescription() {
378 private void setDescription(final String description) {
379 this.description = description;
383 public String getReference() {
387 private void setReference(final String reference) {
388 this.reference = reference;
392 public Status getStatus() {
396 private void setStatus(Status status) {
397 this.status = status;
401 public List<QName> getKeyDefinition() {
402 return keyDefinition;
405 private void setKeyDefinition(List<QName> keyDefinition) {
406 if (keyDefinition != null) {
407 this.keyDefinition = keyDefinition;
412 public boolean isAugmenting() {
416 private void setAugmenting(boolean augmenting) {
417 this.augmenting = augmenting;
421 public boolean isAddedByUses() {
425 private void setAddedByUses(final boolean addedByUses) {
426 this.addedByUses = addedByUses;
430 public boolean isConfiguration() {
431 return configuration;
434 private void setConfiguration(boolean configuration) {
435 this.configuration = configuration;
439 public ConstraintDefinition getConstraints() {
443 private void setConstraints(ConstraintDefinition constraints) {
444 this.constraints = constraints;
448 public Set<AugmentationSchema> getAvailableAugmentations() {
449 return augmentations;
452 private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
453 if (augmentations != null) {
454 this.augmentations = augmentations;
459 public Set<DataSchemaNode> getChildNodes() {
460 return new HashSet<DataSchemaNode>(childNodes.values());
463 private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
464 if (childNodes != null) {
465 this.childNodes = childNodes;
470 public Set<GroupingDefinition> getGroupings() {
474 private void setGroupings(Set<GroupingDefinition> groupings) {
475 if (groupings != null) {
476 this.groupings = groupings;
481 public Set<TypeDefinition<?>> getTypeDefinitions() {
482 return typeDefinitions;
485 private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
486 if (typeDefinitions != null) {
487 this.typeDefinitions = typeDefinitions;
492 public Set<UsesNode> getUses() {
496 private void setUses(Set<UsesNode> uses) {
503 public DataSchemaNode getDataChildByName(QName name) {
504 return childNodes.get(name);
508 public DataSchemaNode getDataChildByName(String name) {
509 DataSchemaNode result = null;
510 for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
511 if (entry.getKey().getLocalName().equals(name)) {
512 result = entry.getValue();
520 public boolean isUserOrdered() {
524 private void setUserOrdered(boolean userOrdered) {
525 this.userOrdered = userOrdered;
529 public List<UnknownSchemaNode> getUnknownSchemaNodes() {
533 private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
534 if (unknownNodes != null) {
535 this.unknownNodes = unknownNodes;
539 public ListSchemaNodeBuilder toBuilder() {
540 return ListSchemaNodeBuilder.this;
544 public int hashCode() {
545 final int prime = 31;
547 result = prime * result + ((qname == null) ? 0 : qname.hashCode());
548 result = prime * result + ((path == null) ? 0 : path.hashCode());
553 public boolean equals(Object obj) {
560 if (getClass() != obj.getClass()) {
563 final ListSchemaNodeImpl other = (ListSchemaNodeImpl) obj;
565 if (other.qname != null) {
568 } else if (!qname.equals(other.qname)) {
572 if (other.path != null) {
575 } else if (!path.equals(other.path)) {
582 public String toString() {
583 StringBuilder sb = new StringBuilder(ListSchemaNodeImpl.class.getSimpleName());
585 sb.append("qname=" + qname);
586 sb.append(", path=" + path);
587 sb.append(", keyDefinition=" + keyDefinition);
589 return sb.toString();