opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/builder/impl/ChoiceCaseBuilder.java

   1 package org.opendaylight.controller.yang.model.parser.builder.impl;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collections;
   5 import java.util.HashMap;
   6 import java.util.HashSet;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Set;
  10
  11 import org.opendaylight.controller.yang.common.QName;
  12 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
  13 import org.opendaylight.controller.yang.model.api.ChoiceCaseNode;
  14 import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
  15 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
  16 import org.opendaylight.controller.yang.model.api.GroupingDefinition;
  17 import org.opendaylight.controller.yang.model.api.SchemaPath;
  18 import org.opendaylight.controller.yang.model.api.Status;
  19 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  20 import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
  21 import org.opendaylight.controller.yang.model.api.UsesNode;
  22 import org.opendaylight.controller.yang.model.parser.builder.api.AbstractChildNodeBuilder;
  23 import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;
  24 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
  25 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
  26
  27 public final class ChoiceCaseBuilder extends AbstractChildNodeBuilder implements
  28         DataSchemaNodeBuilder {
  29     private final ChoiceCaseNodeImpl instance;
  30     private SchemaPath schemaPath;
  31     private String description;
  32     private String reference;
  33     private Status status = Status.CURRENT;
  34     private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
  35     private boolean augmenting;
  36     private final ConstraintsBuilder constraints;
  37     private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
  38     private final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
  39
  40     ChoiceCaseBuilder(QName qname) {
  41         super(qname);
  42         instance = new ChoiceCaseNodeImpl(qname);
  43         constraints = new ConstraintsBuilder();
  44     }
  45
  46     @Override
  47     public ChoiceCaseNode build() {
  48         instance.setConstraints(constraints.build());
  49         instance.setPath(schemaPath);
  50         instance.setDescription(description);
  51         instance.setReference(reference);
  52         instance.setStatus(status);
  53         instance.setAugmenting(augmenting);
  54         instance.setAvailableAugmentations(augmentations);
  55
  56         // CHILD NODES
  57         final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
  58         for (DataSchemaNodeBuilder node : childNodes) {
  59             childs.put(node.getQName(), node.build());
  60         }
  61         instance.setChildNodes(childs);
  62
  63         // USES
  64         final Set<UsesNode> uses = new HashSet<UsesNode>();
  65         for (UsesNodeBuilder builder : addedUsesNodes) {
  66             uses.add(builder.build());
  67         }
  68         instance.setUses(uses);
  69
  70         // UNKNOWN NODES
  71         final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
  72         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
  73             unknownNodes.add(b.build());
  74         }
  75         instance.setUnknownSchemaNodes(unknownNodes);
  76
  77         return instance;
  78     }
  79
  80     public SchemaPath getPath() {
  81         return schemaPath;
  82     }
  83
  84     @Override
  85     public void setPath(final SchemaPath schemaPath) {
  86         this.schemaPath = schemaPath;
  87     }
  88
  89     public String getDescription() {
  90         return description;
  91     }
  92
  93     @Override
  94     public void setDescription(final String description) {
  95         this.description = description;
  96     }
  97
  98     public String getReference() {
  99         return reference;
 100     }
 101
 102     @Override
 103     public void setReference(String reference) {
 104         this.reference = reference;
 105     }
 106
 107     public Status getStatus() {
 108         return status;
 109     }
 110
 111     @Override
 112     public void setStatus(Status status) {
 113         if (status != null) {
 114             this.status = status;
 115         }
 116     }
 117
 118     public boolean isAugmenting() {
 119         return augmenting;
 120     }
 121
 122     @Override
 123     public void setAugmenting(boolean augmenting) {
 124         this.augmenting = augmenting;
 125     }
 126
 127     public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
 128         return addedUnknownNodes;
 129     }
 130
 131     @Override
 132     public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
 133         addedUnknownNodes.add(unknownNode);
 134     }
 135
 136     public Set<UsesNodeBuilder> getUsesNodes() {
 137         return addedUsesNodes;
 138     }
 139
 140     @Override
 141     public void addUsesNode(UsesNodeBuilder usesNodeBuilder) {
 142         addedUsesNodes.add(usesNodeBuilder);
 143     }
 144
 145     @Override
 146     public void addTypedef(TypeDefinitionBuilder typedefBuilder) {
 147         throw new UnsupportedOperationException(
 148                 "Can not add type definition to choice case.");
 149     }
 150
 151     @Override
 152     public void setConfiguration(boolean configuration) {
 153         throw new UnsupportedOperationException(
 154                 "Can not add config definition to choice case.");
 155     }
 156
 157     @Override
 158     public ConstraintsBuilder getConstraints() {
 159         return constraints;
 160     }
 161
 162     public Set<AugmentationSchema> getAugmentations() {
 163         return augmentations;
 164     }
 165
 166     private class ChoiceCaseNodeImpl implements ChoiceCaseNode {
 167         private final QName qname;
 168         private SchemaPath path;
 169         private String description;
 170         private String reference;
 171         private Status status = Status.CURRENT;
 172         private boolean augmenting;
 173         private ConstraintDefinition constraints;
 174         private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
 175         private Set<AugmentationSchema> augmentations = Collections.emptySet();
 176         private Set<UsesNode> uses = Collections.emptySet();
 177         private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
 178
 179         private ChoiceCaseNodeImpl(QName qname) {
 180             this.qname = qname;
 181         }
 182
 183         @Override
 184         public QName getQName() {
 185             return qname;
 186         }
 187
 188         @Override
 189         public SchemaPath getPath() {
 190             return path;
 191         }
 192
 193         private void setPath(SchemaPath path) {
 194             this.path = path;
 195         }
 196
 197         @Override
 198         public String getDescription() {
 199             return description;
 200         }
 201
 202         private void setDescription(String description) {
 203             this.description = description;
 204         }
 205
 206         @Override
 207         public String getReference() {
 208             return reference;
 209         }
 210
 211         private void setReference(String reference) {
 212             this.reference = reference;
 213         }
 214
 215         @Override
 216         public Status getStatus() {
 217             return status;
 218         }
 219
 220         private void setStatus(Status status) {
 221             if (status != null) {
 222                 this.status = status;
 223             }
 224         }
 225
 226         @Override
 227         public boolean isConfiguration() {
 228             return false;
 229         }
 230
 231         @Override
 232         public ConstraintDefinition getConstraints() {
 233             return constraints;
 234         }
 235
 236         private void setConstraints(ConstraintDefinition constraints) {
 237             this.constraints = constraints;
 238         }
 239
 240         @Override
 241         public boolean isAugmenting() {
 242             return augmenting;
 243         }
 244
 245         private void setAugmenting(boolean augmenting) {
 246             this.augmenting = augmenting;
 247         }
 248
 249         @Override
 250         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 251             return unknownNodes;
 252         }
 253
 254         private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
 255             if (unknownNodes != null) {
 256                 this.unknownNodes = unknownNodes;
 257             }
 258         }
 259
 260         @Override
 261         public Set<TypeDefinition<?>> getTypeDefinitions() {
 262             return Collections.emptySet();
 263         }
 264
 265         @Override
 266         public Set<DataSchemaNode> getChildNodes() {
 267             return new HashSet<DataSchemaNode>(childNodes.values());
 268         }
 269
 270         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
 271             if (childNodes != null) {
 272                 this.childNodes = childNodes;
 273             }
 274         }
 275
 276         @Override
 277         public Set<GroupingDefinition> getGroupings() {
 278             return Collections.emptySet();
 279         }
 280
 281         @Override
 282         public DataSchemaNode getDataChildByName(QName name) {
 283             return childNodes.get(name);
 284         }
 285
 286         @Override
 287         public DataSchemaNode getDataChildByName(String name) {
 288             DataSchemaNode result = null;
 289             for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
 290                 if (entry.getKey().getLocalName().equals(name)) {
 291                     result = entry.getValue();
 292                     break;
 293                 }
 294             }
 295             return result;
 296         }
 297
 298         @Override
 299         public Set<UsesNode> getUses() {
 300             return uses;
 301         }
 302
 303         private void setUses(Set<UsesNode> uses) {
 304             if (uses != null) {
 305                 this.uses = uses;
 306             }
 307         }
 308
 309         @Override
 310         public Set<AugmentationSchema> getAvailableAugmentations() {
 311             return augmentations;
 312         }
 313
 314         private void setAvailableAugmentations(
 315                 Set<AugmentationSchema> augmentations) {
 316             if (augmentations != null) {
 317                 this.augmentations = augmentations;
 318             }
 319         }
 320
 321         @Override
 322         public int hashCode() {
 323             final int prime = 31;
 324             int result = 1;
 325             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 326             result = prime * result + ((path == null) ? 0 : path.hashCode());
 327             return result;
 328         }
 329
 330         @Override
 331         public boolean equals(Object obj) {
 332             if (this == obj) {
 333                 return true;
 334             }
 335             if (obj == null) {
 336                 return false;
 337             }
 338             if (getClass() != obj.getClass()) {
 339                 return false;
 340             }
 341             ChoiceCaseNodeImpl other = (ChoiceCaseNodeImpl) obj;
 342             if (qname == null) {
 343                 if (other.qname != null) {
 344                     return false;
 345                 }
 346             } else if (!qname.equals(other.qname)) {
 347                 return false;
 348             }
 349             if (path == null) {
 350                 if (other.path != null) {
 351                     return false;
 352                 }
 353             } else if (!path.equals(other.path)) {
 354                 return false;
 355             }
 356             return true;
 357         }
 358
 359         @Override
 360         public String toString() {
 361             StringBuilder sb = new StringBuilder(
 362                     ChoiceCaseNodeImpl.class.getSimpleName());
 363             sb.append("[");
 364             sb.append("qname=" + qname);
 365             sb.append("]");
 366             return sb.toString();
 367         }
 368
 369     }
 370
 371 }