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;
11 import java.util.ArrayList;
12 import java.util.Collections;
13 import java.util.Date;
14 import java.util.HashSet;
15 import java.util.List;
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.ChoiceCaseNode;
22 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
23 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
24 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
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.UnknownSchemaNode;
28 import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
29 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
30 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
31 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
32 import org.opendaylight.yangtools.yang.parser.util.Comparators;
33 import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
34 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
36 public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder,
37 AugmentationTargetBuilder {
38 private boolean isBuilt;
39 private final ChoiceNodeImpl instance;
40 // DataSchemaNode args
41 private final ConstraintsBuilder constraints;
42 // AugmentationTarget args
43 private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
45 private final Set<ChoiceCaseBuilder> caseBuilders = new HashSet<>();
46 private String defaultCase;
48 public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
49 super(moduleName, line, qname);
50 this.schemaPath = path;
51 instance = new ChoiceNodeImpl(qname, path);
52 constraints = new ConstraintsBuilder(moduleName, line);
55 public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
56 final ChoiceNode base) {
57 super(moduleName, line, qname);
58 this.schemaPath = path;
59 instance = new ChoiceNodeImpl(qname, path);
60 constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
62 instance.description = base.getDescription();
63 instance.reference = base.getReference();
64 instance.status = base.getStatus();
65 instance.augmenting = base.isAugmenting();
66 instance.addedByUses = base.isAddedByUses();
67 instance.configuration = base.isConfiguration();
68 instance.constraints = base.getConstraints();
69 instance.augmentations.addAll(base.getAvailableAugmentations());
71 URI ns = qname.getNamespace();
72 Date rev = qname.getRevision();
73 String pref = qname.getPrefix();
74 Set<DataSchemaNodeBuilder> wrapped = ParserUtils.wrapChildNodes(moduleName, line, new HashSet<DataSchemaNode>(
75 base.getCases()), path, ns, rev, pref);
76 for (DataSchemaNodeBuilder wrap : wrapped) {
77 if (wrap instanceof ChoiceCaseBuilder) {
78 caseBuilders.add((ChoiceCaseBuilder) wrap);
82 instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
86 public ChoiceNode build() {
88 instance.setConstraints(constraints.build());
89 instance.setDefaultCase(defaultCase);
92 final Set<ChoiceCaseNode> cases = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
93 for (ChoiceCaseBuilder caseBuilder : caseBuilders) {
94 cases.add(caseBuilder.build());
96 instance.addCases(cases);
99 final Set<AugmentationSchema> augmentations = new HashSet<>();
100 for (AugmentationSchemaBuilder builder : augmentationBuilders) {
101 augmentations.add(builder.build());
103 instance.addAvailableAugmentations(augmentations);
106 for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
107 unknownNodes.add(b.build());
109 Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
110 instance.addUnknownSchemaNodes(unknownNodes);
117 public Set<ChoiceCaseBuilder> getCases() {
122 public SchemaPath getPath() {
123 return instance.path;
127 public void setPath(final SchemaPath path) {
128 instance.path = path;
135 * name of case to search
136 * @return case with given name if present, null otherwise
138 public ChoiceCaseBuilder getCaseNodeByName(final String caseName) {
139 for (ChoiceCaseBuilder addedCase : caseBuilders) {
140 if (addedCase.getQName().getLocalName().equals(caseName)) {
148 * Add case node to this choice.
150 * If node is not declared with 'case' keyword, create new case builder and
151 * make this node child of newly created case.
156 public void addCase(final DataSchemaNodeBuilder caseNode) {
157 QName caseQName = caseNode.getQName();
158 String caseName = caseQName.getLocalName();
160 for (ChoiceCaseBuilder addedCase : caseBuilders) {
161 if (addedCase.getQName().getLocalName().equals(caseName)) {
162 throw new YangParseException(caseNode.getModuleName(), caseNode.getLine(), "Can not add '" + caseNode
163 + "' to node '" + qname.getLocalName() + "' in module '" + moduleName
164 + "': case with same name already declared at line " + addedCase.getLine());
168 if (caseNode instanceof ChoiceCaseBuilder) {
169 caseBuilders.add((ChoiceCaseBuilder) caseNode);
171 ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(caseNode.getModuleName(), caseNode.getLine(),
172 caseQName, caseNode.getPath());
173 if (caseNode.isAugmenting()) {
174 // if node is added by augmentation, set case builder augmenting
175 // as true and node augmenting as false
176 caseBuilder.setAugmenting(true);
177 caseNode.setAugmenting(false);
179 SchemaPath newPath = ParserUtils.createSchemaPath(caseNode.getPath(), caseQName);
180 caseNode.setPath(newPath);
181 caseBuilder.addChildNode(caseNode);
182 caseBuilders.add(caseBuilder);
187 public String getDescription() {
188 return instance.description;
192 public void setDescription(final String description) {
193 instance.description = description;
197 public String getReference() {
198 return instance.reference;
202 public void setReference(final String reference) {
203 instance.reference = reference;
207 public Status getStatus() {
208 return instance.status;
212 public void setStatus(final Status status) {
213 if (status != null) {
214 instance.status = status;
219 public boolean isAugmenting() {
220 return instance.augmenting;
224 public void setAugmenting(final boolean augmenting) {
225 instance.augmenting = augmenting;
229 public boolean isAddedByUses() {
230 return instance.addedByUses;
234 public void setAddedByUses(final boolean addedByUses) {
235 instance.addedByUses = addedByUses;
239 public boolean isConfiguration() {
240 return instance.configuration;
244 public void setConfiguration(final boolean configuration) {
245 instance.configuration = configuration;
249 public ConstraintsBuilder getConstraints() {
254 public void addAugmentation(final AugmentationSchemaBuilder augment) {
255 augmentationBuilders.add(augment);
258 public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
259 return augmentationBuilders;
262 public String getDefaultCase() {
266 public void setDefaultCase(final String defaultCase) {
267 this.defaultCase = defaultCase;
271 public int hashCode() {
272 final int prime = 31;
274 result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
279 public boolean equals(final Object obj) {
286 if (getClass() != obj.getClass()) {
289 ChoiceBuilder other = (ChoiceBuilder) obj;
290 if (schemaPath == null) {
291 if (other.schemaPath != null) {
294 } else if (!schemaPath.equals(other.schemaPath)) {
297 if (parentBuilder == null) {
298 if (other.parentBuilder != null) {
301 } else if (!parentBuilder.equals(other.parentBuilder)) {
308 public String toString() {
309 return "choice " + qname.getLocalName();
312 private static final class ChoiceNodeImpl implements ChoiceNode {
313 private final QName qname;
314 private SchemaPath path;
315 private String description;
316 private String reference;
317 private Status status = Status.CURRENT;
318 private boolean augmenting;
319 private boolean addedByUses;
320 private boolean configuration;
321 private ConstraintDefinition constraints;
322 private final Set<ChoiceCaseNode> cases = new HashSet<>();
323 private final Set<AugmentationSchema> augmentations = new HashSet<>();
324 private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
325 private String defaultCase;
327 private ChoiceNodeImpl(final QName qname, final SchemaPath path) {
333 public QName getQName() {
338 public SchemaPath getPath() {
343 public String getDescription() {
348 public String getReference() {
353 public Status getStatus() {
358 public boolean isAugmenting() {
363 public boolean isAddedByUses() {
368 public boolean isConfiguration() {
369 return configuration;
373 public ConstraintDefinition getConstraints() {
377 private void setConstraints(final ConstraintDefinition constraints) {
378 this.constraints = constraints;
382 public Set<AugmentationSchema> getAvailableAugmentations() {
383 return Collections.unmodifiableSet(augmentations);
386 private void addAvailableAugmentations(final Set<AugmentationSchema> availableAugmentations) {
387 if (availableAugmentations != null) {
388 this.augmentations.addAll(availableAugmentations);
393 public List<UnknownSchemaNode> getUnknownSchemaNodes() {
394 return Collections.unmodifiableList(unknownNodes);
397 private void addUnknownSchemaNodes(final List<UnknownSchemaNode> unknownSchemaNodes) {
398 if (unknownSchemaNodes != null) {
399 this.unknownNodes.addAll(unknownSchemaNodes);
404 public Set<ChoiceCaseNode> getCases() {
405 return Collections.unmodifiableSet(cases);
409 public ChoiceCaseNode getCaseNodeByName(final QName name) {
411 throw new IllegalArgumentException("Choice Case QName cannot be NULL!");
413 for (final ChoiceCaseNode caseNode : cases) {
414 if (caseNode != null && name.equals(caseNode.getQName())) {
422 public ChoiceCaseNode getCaseNodeByName(final String name) {
424 throw new IllegalArgumentException("Choice Case string Name cannot be NULL!");
426 for (final ChoiceCaseNode caseNode : cases) {
427 if (caseNode != null && (caseNode.getQName() != null)
428 && name.equals(caseNode.getQName().getLocalName())) {
435 private void addCases(final Set<ChoiceCaseNode> cases) {
437 this.cases.addAll(cases);
442 public String getDefaultCase() {
446 private void setDefaultCase(final String defaultCase) {
447 this.defaultCase = defaultCase;
451 public int hashCode() {
452 final int prime = 31;
454 result = prime * result + ((qname == null) ? 0 : qname.hashCode());
455 result = prime * result + ((path == null) ? 0 : path.hashCode());
460 public boolean equals(final Object obj) {
467 if (getClass() != obj.getClass()) {
470 ChoiceNodeImpl other = (ChoiceNodeImpl) obj;
472 if (other.qname != null) {
475 } else if (!qname.equals(other.qname)) {
479 if (other.path != null) {
482 } else if (!path.equals(other.path)) {
489 public String toString() {
490 StringBuilder sb = new StringBuilder(ChoiceNodeImpl.class.getSimpleName());
492 sb.append("qname=" + qname);
494 return sb.toString();