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.model.parser.builder.impl;
10 import java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.HashMap;
13 import java.util.HashSet;
14 import java.util.List;
18 import org.opendaylight.controller.yang.common.QName;
19 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
20 import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
21 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
22 import org.opendaylight.controller.yang.model.api.GroupingDefinition;
23 import org.opendaylight.controller.yang.model.api.ListSchemaNode;
24 import org.opendaylight.controller.yang.model.api.SchemaPath;
25 import org.opendaylight.controller.yang.model.api.Status;
26 import org.opendaylight.controller.yang.model.api.TypeDefinition;
27 import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
28 import org.opendaylight.controller.yang.model.api.UsesNode;
29 import org.opendaylight.controller.yang.model.parser.builder.api.AbstractChildNodeBuilder;
30 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationTargetBuilder;
31 import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;
32 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;
33 import org.opendaylight.controller.yang.model.parser.builder.api.SchemaNodeBuilder;
34 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionAwareBuilder;
35 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
36 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
38 public class ListSchemaNodeBuilder extends AbstractChildNodeBuilder implements
39 DataSchemaNodeBuilder, SchemaNodeBuilder, AugmentationTargetBuilder,
40 TypeDefinitionAwareBuilder {
42 private final ListSchemaNodeImpl instance;
43 private final ConstraintsBuilder constraintsBuilder;
45 private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
46 private final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
47 private final Set<UsesNodeBuilder> usesNodes = new HashSet<UsesNodeBuilder>();
48 private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
50 ListSchemaNodeBuilder(QName qname) {
52 instance = new ListSchemaNodeImpl(qname);
53 constraintsBuilder = new ConstraintsBuilder();
57 public ListSchemaNode build() {
59 Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
60 for (DataSchemaNodeBuilder node : childNodes) {
61 childs.put(node.getQName(), node.build());
63 instance.setChildNodes(childs);
66 Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
67 for (TypeDefinitionBuilder entry : addedTypedefs) {
68 typedefs.add(entry.build());
70 instance.setTypeDefinitions(typedefs);
73 Set<UsesNode> usesNodeDefinitions = new HashSet<UsesNode>();
74 for (UsesNodeBuilder builder : usesNodes) {
75 usesNodeDefinitions.add(builder.build());
77 instance.setUses(usesNodeDefinitions);
80 Set<GroupingDefinition> groupingDefinitions = new HashSet<GroupingDefinition>();
81 for (GroupingBuilder builder : groupings) {
82 groupingDefinitions.add(builder.build());
84 instance.setGroupings(groupingDefinitions);
87 final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
88 for(UnknownSchemaNodeBuilder b : addedUnknownNodes) {
89 unknownNodes.add(b.build());
91 instance.setUnknownSchemaNodes(unknownNodes);
93 instance.setConstraints(constraintsBuilder.build());
94 instance.setAvailableAugmentations(augmentations);
100 public void addTypedef(TypeDefinitionBuilder type) {
101 addedTypedefs.add(type);
105 public void setPath(SchemaPath path) {
106 instance.setPath(path);
110 public void setDescription(String description) {
111 instance.setDescription(description);
115 public void setReference(String reference) {
116 instance.setReference(reference);
120 public void setStatus(Status status) {
122 instance.setStatus(status);
127 public void addUsesNode(UsesNodeBuilder usesBuilder) {
128 usesNodes.add(usesBuilder);
132 public void addAugmentation(AugmentationSchema augmentationSchema) {
133 augmentations.add(augmentationSchema);
136 public void setKeyDefinition(List<QName> keyDefinition) {
137 instance.setKeyDefinition(keyDefinition);
141 public void setAugmenting(boolean augmenting) {
142 instance.setAugmenting(augmenting);
146 public void setConfiguration(boolean configuration) {
147 instance.setConfiguration(configuration);
151 public ConstraintsBuilder getConstraintsBuilder() {
152 return constraintsBuilder;
155 public void setUserOrdered(boolean userOrdered) {
156 instance.setUserOrdered(userOrdered);
160 public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownSchemaNodeBuilder) {
161 addedUnknownNodes.add(unknownSchemaNodeBuilder);
164 private class ListSchemaNodeImpl implements ListSchemaNode {
165 private final QName qname;
166 private SchemaPath path;
167 private String description;
168 private String reference;
169 private Status status = Status.CURRENT;
170 private List<QName> keyDefinition = Collections.emptyList();
171 private boolean augmenting;
172 private boolean configuration;
173 private ConstraintDefinition constraints;
174 private Set<AugmentationSchema> augmentations = Collections.emptySet();
175 private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
176 private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
177 private Set<GroupingDefinition> groupings = Collections.emptySet();
178 private Set<UsesNode> uses = Collections.emptySet();
179 private boolean userOrdered;
180 private List<UnknownSchemaNode> unknownSchemaNodes = Collections.emptyList();
182 private ListSchemaNodeImpl(QName qname) {
187 public QName getQName() {
192 public SchemaPath getPath() {
196 private void setPath(SchemaPath path) {
201 public String getDescription() {
205 private void setDescription(String description) {
206 this.description = description;
210 public String getReference() {
214 private void setReference(String reference) {
215 this.reference = reference;
219 public Status getStatus() {
223 private void setStatus(Status status) {
224 this.status = status;
228 public List<QName> getKeyDefinition() {
229 if(keyDefinition == null) {
230 return Collections.emptyList();
232 return keyDefinition;
236 private void setKeyDefinition(List<QName> keyDefinition) {
237 if(keyDefinition != null) {
238 this.keyDefinition = keyDefinition;
243 public boolean isAugmenting() {
247 private void setAugmenting(boolean augmenting) {
248 this.augmenting = augmenting;
252 public boolean isConfiguration() {
253 return configuration;
256 private void setConfiguration(boolean configuration) {
257 this.configuration = configuration;
261 public ConstraintDefinition getConstraints() {
265 private void setConstraints(ConstraintDefinition constraints) {
266 this.constraints = constraints;
270 public Set<AugmentationSchema> getAvailableAugmentations() {
271 return augmentations;
274 private void setAvailableAugmentations(
275 Set<AugmentationSchema> augmentations) {
276 if(augmentations != null) {
277 this.augmentations = augmentations;
282 public Set<DataSchemaNode> getChildNodes() {
283 return new HashSet<DataSchemaNode>(childNodes.values());
286 private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
287 if(childNodes != null) {
288 this.childNodes = childNodes;
293 public Set<GroupingDefinition> getGroupings() {
297 private void setGroupings(Set<GroupingDefinition> groupings) {
298 if(groupings != null) {
299 this.groupings = groupings;
304 public Set<TypeDefinition<?>> getTypeDefinitions() {
305 return typeDefinitions;
308 private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
309 if(typeDefinitions != null) {
310 this.typeDefinitions = typeDefinitions;
315 public Set<UsesNode> getUses() {
319 private void setUses(Set<UsesNode> uses) {
326 public DataSchemaNode getDataChildByName(QName name) {
327 return childNodes.get(name);
331 public DataSchemaNode getDataChildByName(String name) {
332 DataSchemaNode result = null;
333 for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
334 if (entry.getKey().getLocalName().equals(name)) {
335 result = entry.getValue();
343 public boolean isUserOrdered() {
347 private void setUserOrdered(boolean userOrdered) {
348 this.userOrdered = userOrdered;
352 public List<UnknownSchemaNode> getUnknownSchemaNodes() {
353 return unknownSchemaNodes;
356 private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
357 if(unknownSchemaNodes != null) {
358 this.unknownSchemaNodes = unknownSchemaNodes;
363 public int hashCode() {
364 final int prime = 31;
366 result = prime * result + ((qname == null) ? 0 : qname.hashCode());
367 result = prime * result + ((path == null) ? 0 : path.hashCode());
372 public boolean equals(Object obj) {
379 if (getClass() != obj.getClass()) {
382 ListSchemaNodeImpl other = (ListSchemaNodeImpl) obj;
384 if (other.qname != null) {
387 } else if (!qname.equals(other.qname)) {
391 if (other.path != null) {
394 } else if (!path.equals(other.path)) {
401 public String toString() {
402 StringBuilder sb = new StringBuilder(
403 ListSchemaNodeImpl.class.getSimpleName());
405 sb.append("qname=" + qname);
406 sb.append(", path=" + path);
407 sb.append(", description=" + description);
408 sb.append(", reference=" + reference);
409 sb.append(", status=" + status);
410 sb.append(", keyDefinition=" + keyDefinition);
411 sb.append(", augmenting=" + augmenting);
412 sb.append(", configuration=" + configuration);
413 sb.append(", constraints=" + constraints);
414 sb.append(", augmentations=" + augmentations);
415 sb.append(", childNodes=" + childNodes.values());
416 sb.append(", typedefinitions=" + typeDefinitions);
417 sb.append(", groupings=" + groupings);
418 sb.append(", uses=" + uses);
419 sb.append(", userOrdered=" + userOrdered);
421 return sb.toString();