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 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         @Override
 269         public Set<TypeDefinition<?>> getTypeDefinitions() {
 270             return Collections.emptySet();
 271         }
 272
 273         @Override
 274         public Set<DataSchemaNode> getChildNodes() {
 275             return new HashSet<DataSchemaNode>(childNodes.values());
 276         }
 277
 278         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
 279             if (childNodes != null) {
 280                 this.childNodes = childNodes;
 281             }
 282         }
 283
 284         @Override
 285         public Set<GroupingDefinition> getGroupings() {
 286             return Collections.emptySet();
 287         }
 288
 289         @Override
 290         public DataSchemaNode getDataChildByName(QName name) {
 291             return childNodes.get(name);
 292         }
 293
 294         @Override
 295         public DataSchemaNode getDataChildByName(String name) {
 296             DataSchemaNode result = null;
 297             for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
 298                 if (entry.getKey().getLocalName().equals(name)) {
 299                     result = entry.getValue();
 300                     break;
 301                 }
 302             }
 303             return result;
 304         }
 305
 306         @Override
 307         public Set<UsesNode> getUses() {
 308             return uses;
 309         }
 310
 311         private void setUses(Set<UsesNode> uses) {
 312             if (uses != null) {
 313                 this.uses = uses;
 314             }
 315         }
 316
 317         @Override
 318         public Set<AugmentationSchema> getAvailableAugmentations() {
 319             return augmentations;
 320         }
 321
 322         private void setAvailableAugmentations(
 323                 Set<AugmentationSchema> augmentations) {
 324             if (augmentations != null) {
 325                 this.augmentations = augmentations;
 326             }
 327         }
 328
 329         @Override
 330         public int hashCode() {
 331             final int prime = 31;
 332             int result = 1;
 333             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 334             result = prime * result + ((path == null) ? 0 : path.hashCode());
 335             return result;
 336         }
 337
 338         @Override
 339         public boolean equals(Object obj) {
 340             if (this == obj) {
 341                 return true;
 342             }
 343             if (obj == null) {
 344                 return false;
 345             }
 346             if (getClass() != obj.getClass()) {
 347                 return false;
 348             }
 349             ChoiceCaseNodeImpl other = (ChoiceCaseNodeImpl) obj;
 350             if (qname == null) {
 351                 if (other.qname != null) {
 352                     return false;
 353                 }
 354             } else if (!qname.equals(other.qname)) {
 355                 return false;
 356             }
 357             if (path == null) {
 358                 if (other.path != null) {
 359                     return false;
 360                 }
 361             } else if (!path.equals(other.path)) {
 362                 return false;
 363             }
 364             return true;
 365         }
 366
 367         @Override
 368         public String toString() {
 369             StringBuilder sb = new StringBuilder(
 370                     ChoiceCaseNodeImpl.class.getSimpleName());
 371             sb.append("[");
 372             sb.append("qname=" + qname);
 373             sb.append("]");
 374             return sb.toString();
 375         }
 376     }
 377
 378 }