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 class ChoiceCaseBuilder extends AbstractChildNodeBuilder implements DataSchemaNodeBuilder {
  28
  29     private final ChoiceCaseNodeImpl instance;
  30     private final ConstraintsBuilder constraints;
  31     private SchemaPath schemaPath;
  32     private String description;
  33     private String reference;
  34     private Status status = Status.CURRENT;
  35     private boolean augmenting;
  36     private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
  37     private final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
  38     private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
  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("Can not add type definition to choice case.");
 148     }
 149
 150     @Override
 151     public void setConfiguration(boolean configuration) {
 152         throw new UnsupportedOperationException("Can not add config definition to choice case.");
 153     }
 154
 155     @Override
 156     public ConstraintsBuilder getConstraints() {
 157         return constraints;
 158     }
 159
 160     public Set<AugmentationSchema> getAugmentations() {
 161         return augmentations;
 162     }
 163
 164
 165     private static class ChoiceCaseNodeImpl implements ChoiceCaseNode {
 166         private final QName qname;
 167         private SchemaPath path;
 168         private String description;
 169         private String reference;
 170         private Status status = Status.CURRENT;
 171         private boolean augmenting;
 172         private ConstraintDefinition constraints;
 173         private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
 174         private Set<AugmentationSchema> augmentations = Collections.emptySet();
 175         private Set<UsesNode> uses = Collections.emptySet();
 176         private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
 177
 178         private ChoiceCaseNodeImpl(QName qname) {
 179             this.qname = qname;
 180         }
 181
 182         @Override
 183         public QName getQName() {
 184             return qname;
 185         }
 186
 187         @Override
 188         public SchemaPath getPath() {
 189             return path;
 190         }
 191
 192         private void setPath(SchemaPath path) {
 193             this.path = path;
 194         }
 195
 196         @Override
 197         public String getDescription() {
 198             return description;
 199         }
 200
 201         private void setDescription(String description) {
 202             this.description = description;
 203         }
 204
 205         @Override
 206         public String getReference() {
 207             return reference;
 208         }
 209
 210         private void setReference(String reference) {
 211             this.reference = reference;
 212         }
 213
 214         @Override
 215         public Status getStatus() {
 216             return status;
 217         }
 218
 219         private void setStatus(Status status) {
 220             if(status != null) {
 221                 this.status = status;
 222             }
 223         }
 224
 225         @Override
 226         public boolean isConfiguration() {
 227             return false;
 228         }
 229
 230         @Override
 231         public ConstraintDefinition getConstraints() {
 232             return constraints;
 233         }
 234
 235         private void setConstraints(ConstraintDefinition constraints) {
 236             this.constraints = constraints;
 237         }
 238
 239         @Override
 240         public boolean isAugmenting() {
 241             return augmenting;
 242         }
 243
 244         private void setAugmenting(boolean augmenting) {
 245             this.augmenting = augmenting;
 246         }
 247
 248         @Override
 249         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 250             return unknownNodes;
 251         }
 252
 253         private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
 254             if(unknownNodes != null) {
 255                 this.unknownNodes = unknownNodes;
 256             }
 257         }
 258
 259         @Override
 260         public Set<TypeDefinition<?>> getTypeDefinitions() {
 261             return Collections.emptySet();
 262         }
 263
 264         @Override
 265         public Set<DataSchemaNode> getChildNodes() {
 266             return new HashSet<DataSchemaNode>(childNodes.values());
 267         }
 268
 269         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
 270             if (childNodes != null) {
 271                 this.childNodes = childNodes;
 272             }
 273         }
 274
 275         @Override
 276         public Set<GroupingDefinition> getGroupings() {
 277             return Collections.emptySet();
 278         }
 279
 280         @Override
 281         public DataSchemaNode getDataChildByName(QName name) {
 282             return childNodes.get(name);
 283         }
 284
 285         @Override
 286         public DataSchemaNode getDataChildByName(String name) {
 287             DataSchemaNode result = null;
 288             for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
 289                 if (entry.getKey().getLocalName().equals(name)) {
 290                     result = entry.getValue();
 291                     break;
 292                 }
 293             }
 294             return result;
 295         }
 296
 297         @Override
 298         public Set<UsesNode> getUses() {
 299             return uses;
 300         }
 301
 302         private void setUses(Set<UsesNode> uses) {
 303             if (uses != null) {
 304                 this.uses = uses;
 305             }
 306         }
 307
 308         @Override
 309         public Set<AugmentationSchema> getAvailableAugmentations() {
 310             return augmentations;
 311         }
 312
 313         private void setAvailableAugmentations(
 314                 Set<AugmentationSchema> augmentations) {
 315             if (augmentations != null) {
 316                 this.augmentations = augmentations;
 317             }
 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 }