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