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

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