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.AbstractChildNodeBuilder;
  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 AbstractChildNodeBuilder 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 void addTypedef(TypeDefinitionBuilder typedefBuilder) {
 155         throw new YangParseException(line,
 156                 "Can not add type definition to choice case.");
 157     }
 158
 159     @Override
 160     public void setConfiguration(boolean configuration) {
 161         throw new YangParseException(line,
 162                 "Can not add config definition to choice case.");
 163     }
 164
 165     @Override
 166     public ConstraintsBuilder getConstraints() {
 167         return constraints;
 168     }
 169
 170     public Set<AugmentationSchema> getAugmentations() {
 171         return augmentations;
 172     }
 173
 174     private final class ChoiceCaseNodeImpl implements ChoiceCaseNode {
 175         private final QName qname;
 176         private SchemaPath path;
 177         private String description;
 178         private String reference;
 179         private Status status = Status.CURRENT;
 180         private boolean augmenting;
 181         private ConstraintDefinition constraints;
 182         private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
 183         private Set<AugmentationSchema> augmentations = Collections.emptySet();
 184         private Set<UsesNode> uses = Collections.emptySet();
 185         private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
 186
 187         private ChoiceCaseNodeImpl(QName qname) {
 188             this.qname = qname;
 189         }
 190
 191         @Override
 192         public QName getQName() {
 193             return qname;
 194         }
 195
 196         @Override
 197         public SchemaPath getPath() {
 198             return path;
 199         }
 200
 201         private void setPath(SchemaPath path) {
 202             this.path = path;
 203         }
 204
 205         @Override
 206         public String getDescription() {
 207             return description;
 208         }
 209
 210         private void setDescription(String description) {
 211             this.description = description;
 212         }
 213
 214         @Override
 215         public String getReference() {
 216             return reference;
 217         }
 218
 219         private void setReference(String reference) {
 220             this.reference = reference;
 221         }
 222
 223         @Override
 224         public Status getStatus() {
 225             return status;
 226         }
 227
 228         private void setStatus(Status status) {
 229             if (status != null) {
 230                 this.status = status;
 231             }
 232         }
 233
 234         @Override
 235         public boolean isConfiguration() {
 236             return false;
 237         }
 238
 239         @Override
 240         public ConstraintDefinition getConstraints() {
 241             return constraints;
 242         }
 243
 244         private void setConstraints(ConstraintDefinition constraints) {
 245             this.constraints = constraints;
 246         }
 247
 248         @Override
 249         public boolean isAugmenting() {
 250             return augmenting;
 251         }
 252
 253         private void setAugmenting(boolean augmenting) {
 254             this.augmenting = augmenting;
 255         }
 256
 257         @Override
 258         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 259             return unknownNodes;
 260         }
 261
 262         private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
 263             if (unknownNodes != null) {
 264                 this.unknownNodes = unknownNodes;
 265             }
 266         }
 267
 268         /**
 269          * Always returns an empty set, because case node can not contains type
 270          * definitions.
 271          */
 272         @Override
 273         public Set<TypeDefinition<?>> getTypeDefinitions() {
 274             return Collections.emptySet();
 275         }
 276
 277         @Override
 278         public Set<DataSchemaNode> getChildNodes() {
 279             return new HashSet<DataSchemaNode>(childNodes.values());
 280         }
 281
 282         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
 283             if (childNodes != null) {
 284                 this.childNodes = childNodes;
 285             }
 286         }
 287
 288         @Override
 289         public Set<GroupingDefinition> getGroupings() {
 290             return Collections.emptySet();
 291         }
 292
 293         @Override
 294         public DataSchemaNode getDataChildByName(QName name) {
 295             return childNodes.get(name);
 296         }
 297
 298         @Override
 299         public DataSchemaNode getDataChildByName(String name) {
 300             DataSchemaNode result = null;
 301             for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
 302                 if (entry.getKey().getLocalName().equals(name)) {
 303                     result = entry.getValue();
 304                     break;
 305                 }
 306             }
 307             return result;
 308         }
 309
 310         @Override
 311         public Set<UsesNode> getUses() {
 312             return uses;
 313         }
 314
 315         private void setUses(Set<UsesNode> uses) {
 316             if (uses != null) {
 317                 this.uses = uses;
 318             }
 319         }
 320
 321         @Override
 322         public Set<AugmentationSchema> getAvailableAugmentations() {
 323             return augmentations;
 324         }
 325
 326         private void setAvailableAugmentations(
 327                 Set<AugmentationSchema> augmentations) {
 328             if (augmentations != null) {
 329                 this.augmentations = augmentations;
 330             }
 331         }
 332
 333         @Override
 334         public int hashCode() {
 335             final int prime = 31;
 336             int result = 1;
 337             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 338             result = prime * result + ((path == null) ? 0 : path.hashCode());
 339             return result;
 340         }
 341
 342         @Override
 343         public boolean equals(Object obj) {
 344             if (this == obj) {
 345                 return true;
 346             }
 347             if (obj == null) {
 348                 return false;
 349             }
 350             if (getClass() != obj.getClass()) {
 351                 return false;
 352             }
 353             ChoiceCaseNodeImpl other = (ChoiceCaseNodeImpl) obj;
 354             if (qname == null) {
 355                 if (other.qname != null) {
 356                     return false;
 357                 }
 358             } else if (!qname.equals(other.qname)) {
 359                 return false;
 360             }
 361             if (path == null) {
 362                 if (other.path != null) {
 363                     return false;
 364                 }
 365             } else if (!path.equals(other.path)) {
 366                 return false;
 367             }
 368             return true;
 369         }
 370
 371         @Override
 372         public String toString() {
 373             StringBuilder sb = new StringBuilder(
 374                     ChoiceCaseNodeImpl.class.getSimpleName());
 375             sb.append("[");
 376             sb.append("qname=" + qname);
 377             sb.append("]");
 378             return sb.toString();
 379         }
 380     }
 381
 382 }