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

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.yang.model.parser.builder.impl;
   9
  10 import java.util.ArrayList;
  11 import java.util.Collections;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.opendaylight.controller.yang.common.QName;
  17 import org.opendaylight.controller.yang.model.api.AugmentationSchema;
  18 import org.opendaylight.controller.yang.model.api.ChoiceCaseNode;
  19 import org.opendaylight.controller.yang.model.api.ChoiceNode;
  20 import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
  21 import org.opendaylight.controller.yang.model.api.SchemaPath;
  22 import org.opendaylight.controller.yang.model.api.Status;
  23 import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
  24 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationSchemaBuilder;
  25 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationTargetBuilder;
  26 import org.opendaylight.controller.yang.model.parser.builder.api.ChildNodeBuilder;
  27 import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;
  28 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;
  29 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
  30 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
  31
  32 public class ChoiceBuilder implements DataSchemaNodeBuilder, ChildNodeBuilder,
  33         AugmentationTargetBuilder {
  34     private final ChoiceNodeImpl instance;
  35     // SchemaNode args
  36     private final QName qname;
  37     private SchemaPath schemaPath;
  38     private String description;
  39     private String reference;
  40     private Status status = Status.CURRENT;
  41     private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
  42     // DataSchemaNode args
  43     private boolean augmenting;
  44     private boolean configuration;
  45     private final ConstraintsBuilder constraints;
  46     // DataNodeContainer args
  47     private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
  48     private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
  49     // AugmentationTarget args
  50     private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
  51     // ChoiceNode args
  52     private final Set<ChoiceCaseBuilder> cases = new HashSet<ChoiceCaseBuilder>();
  53     private String defaultCase;
  54
  55     public ChoiceBuilder(QName qname) {
  56         this.qname = qname;
  57         instance = new ChoiceNodeImpl(qname);
  58         constraints = new ConstraintsBuilder();
  59     }
  60
  61     @Override
  62     public ChoiceNode build() {
  63         instance.setPath(schemaPath);
  64         instance.setDescription(description);
  65         instance.setReference(reference);
  66         instance.setStatus(status);
  67         instance.setAugmenting(augmenting);
  68         instance.setConfiguration(configuration);
  69         instance.setConstraints(constraints.build());
  70         instance.setDefaultCase(defaultCase);
  71
  72         // CASES
  73         final Set<ChoiceCaseNode> choiceCases = new HashSet<ChoiceCaseNode>();
  74         for (ChoiceCaseBuilder caseBuilder : cases) {
  75             choiceCases.add(caseBuilder.build());
  76         }
  77         instance.setCases(choiceCases);
  78
  79         // AUGMENTATIONS
  80         final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
  81         for (AugmentationSchemaBuilder builder : addedAugmentations) {
  82             augmentations.add(builder.build());
  83         }
  84         instance.setAvailableAugmentations(augmentations);
  85
  86         // UNKNOWN NODES
  87         final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
  88         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
  89             unknownNodes.add(b.build());
  90         }
  91         instance.setUnknownSchemaNodes(unknownNodes);
  92
  93         return instance;
  94     }
  95
  96     public Set<ChoiceCaseBuilder> getCases() {
  97         return cases;
  98     }
  99
 100     @Override
 101     public void addChildNode(DataSchemaNodeBuilder childNode) {
 102         if (!(childNode instanceof ChoiceCaseBuilder)) {
 103             ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(
 104                     childNode.getQName());
 105             caseBuilder.addChildNode(childNode);
 106             cases.add(caseBuilder);
 107         } else {
 108             cases.add((ChoiceCaseBuilder) childNode);
 109         }
 110     }
 111
 112     @Override
 113     public QName getQName() {
 114         return qname;
 115     }
 116
 117     /**
 118      * Choice can not contains grouping statements, so this method always
 119      * returns an empty set.
 120      *
 121      * @return
 122      */
 123     public Set<GroupingBuilder> getGroupings() {
 124         return Collections.emptySet();
 125     }
 126
 127     @Override
 128     public void addGrouping(GroupingBuilder groupingBuilder) {
 129         throw new IllegalStateException(
 130                 "Can not add grouping to 'choice' node.");
 131     }
 132
 133     public Set<TypeDefinitionBuilder> getTypedefs() {
 134         return addedTypedefs;
 135     }
 136
 137     @Override
 138     public void addTypedef(final TypeDefinitionBuilder type) {
 139         addedTypedefs.add(type);
 140     }
 141
 142     public SchemaPath getPath() {
 143         return schemaPath;
 144     }
 145
 146     @Override
 147     public void setPath(final SchemaPath schemaPath) {
 148         this.schemaPath = schemaPath;
 149     }
 150
 151     public String getDescription() {
 152         return description;
 153     }
 154
 155     @Override
 156     public void setDescription(final String description) {
 157         this.description = description;
 158     }
 159
 160     public String getReference() {
 161         return reference;
 162     }
 163
 164     @Override
 165     public void setReference(String reference) {
 166         this.reference = reference;
 167     }
 168
 169     public Status getStatus() {
 170         return status;
 171     }
 172
 173     @Override
 174     public void setStatus(Status status) {
 175         if (status != null) {
 176             this.status = status;
 177         }
 178     }
 179
 180     public boolean isAugmenting() {
 181         return augmenting;
 182     }
 183
 184     @Override
 185     public void setAugmenting(boolean augmenting) {
 186         this.augmenting = augmenting;
 187     }
 188
 189     public boolean isConfiguration() {
 190         return configuration;
 191     }
 192
 193     @Override
 194     public void setConfiguration(boolean configuration) {
 195         this.configuration = configuration;
 196     }
 197
 198     @Override
 199     public ConstraintsBuilder getConstraints() {
 200         return constraints;
 201     }
 202
 203     public Set<UsesNodeBuilder> getUsesNodes() {
 204         return addedUsesNodes;
 205     }
 206
 207     @Override
 208     public void addUsesNode(UsesNodeBuilder usesNodeBuilder) {
 209         addedUsesNodes.add(usesNodeBuilder);
 210     }
 211
 212     public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
 213         return addedUnknownNodes;
 214     }
 215
 216     public Set<AugmentationSchemaBuilder> getAugmentations() {
 217         return addedAugmentations;
 218     }
 219
 220     @Override
 221     public void addAugmentation(AugmentationSchemaBuilder augment) {
 222         addedAugmentations.add(augment);
 223     }
 224
 225     @Override
 226     public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownNode) {
 227         addedUnknownNodes.add(unknownNode);
 228     }
 229
 230     public String getDefaultCase() {
 231         return defaultCase;
 232     }
 233
 234     public void setDefaultCase(String defaultCase) {
 235         this.defaultCase = defaultCase;
 236     }
 237
 238     @Override
 239     public Set<DataSchemaNodeBuilder> getChildNodes() {
 240         return new HashSet<DataSchemaNodeBuilder>(cases);
 241     }
 242
 243     private static class ChoiceNodeImpl implements ChoiceNode {
 244         private final QName qname;
 245         private SchemaPath path;
 246         private String description;
 247         private String reference;
 248         private Status status = Status.CURRENT;
 249         private boolean augmenting;
 250         private boolean configuration;
 251         private ConstraintDefinition constraints;
 252         private Set<ChoiceCaseNode> cases = Collections.emptySet();
 253         private Set<AugmentationSchema> augmentations = Collections.emptySet();
 254         private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
 255         private String defaultCase;
 256
 257         private ChoiceNodeImpl(QName qname) {
 258             this.qname = qname;
 259         }
 260
 261         @Override
 262         public QName getQName() {
 263             return qname;
 264         }
 265
 266         @Override
 267         public SchemaPath getPath() {
 268             return path;
 269         }
 270
 271         private void setPath(SchemaPath path) {
 272             this.path = path;
 273         }
 274
 275         @Override
 276         public String getDescription() {
 277             return description;
 278         }
 279
 280         private void setDescription(String description) {
 281             this.description = description;
 282         }
 283
 284         @Override
 285         public String getReference() {
 286             return reference;
 287         }
 288
 289         private void setReference(String reference) {
 290             this.reference = reference;
 291         }
 292
 293         @Override
 294         public Status getStatus() {
 295             return status;
 296         }
 297
 298         private void setStatus(Status status) {
 299             if (status != null) {
 300                 this.status = status;
 301             }
 302         }
 303
 304         @Override
 305         public boolean isAugmenting() {
 306             return augmenting;
 307         }
 308
 309         private void setAugmenting(boolean augmenting) {
 310             this.augmenting = augmenting;
 311         }
 312
 313         @Override
 314         public boolean isConfiguration() {
 315             return configuration;
 316         }
 317
 318         private void setConfiguration(boolean configuration) {
 319             this.configuration = configuration;
 320         }
 321
 322         @Override
 323         public ConstraintDefinition getConstraints() {
 324             return constraints;
 325         }
 326
 327         private void setConstraints(ConstraintDefinition constraints) {
 328             this.constraints = constraints;
 329         }
 330
 331         @Override
 332         public Set<AugmentationSchema> getAvailableAugmentations() {
 333             return augmentations;
 334         }
 335
 336         private void setAvailableAugmentations(
 337                 Set<AugmentationSchema> availableAugmentations) {
 338             if (availableAugmentations != null) {
 339                 this.augmentations = availableAugmentations;
 340             }
 341         }
 342
 343         @Override
 344         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 345             return unknownNodes;
 346         }
 347
 348         private void setUnknownSchemaNodes(
 349                 List<UnknownSchemaNode> unknownSchemaNodes) {
 350             if (unknownSchemaNodes != null) {
 351                 this.unknownNodes = unknownSchemaNodes;
 352             }
 353         }
 354
 355         @Override
 356         public Set<ChoiceCaseNode> getCases() {
 357             return cases;
 358         }
 359
 360         private void setCases(Set<ChoiceCaseNode> cases) {
 361             if (cases != null) {
 362                 this.cases = cases;
 363             }
 364         }
 365
 366         public String getDefaultCase() {
 367             return defaultCase;
 368         }
 369
 370         private void setDefaultCase(String defaultCase) {
 371             this.defaultCase = defaultCase;
 372         }
 373
 374         @Override
 375         public int hashCode() {
 376             final int prime = 31;
 377             int result = 1;
 378             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 379             result = prime * result + ((path == null) ? 0 : path.hashCode());
 380             return result;
 381         }
 382
 383         @Override
 384         public boolean equals(Object obj) {
 385             if (this == obj) {
 386                 return true;
 387             }
 388             if (obj == null) {
 389                 return false;
 390             }
 391             if (getClass() != obj.getClass()) {
 392                 return false;
 393             }
 394             ChoiceNodeImpl other = (ChoiceNodeImpl) obj;
 395             if (qname == null) {
 396                 if (other.qname != null) {
 397                     return false;
 398                 }
 399             } else if (!qname.equals(other.qname)) {
 400                 return false;
 401             }
 402             if (path == null) {
 403                 if (other.path != null) {
 404                     return false;
 405                 }
 406             } else if (!path.equals(other.path)) {
 407                 return false;
 408             }
 409             return true;
 410         }
 411
 412         @Override
 413         public String toString() {
 414             StringBuilder sb = new StringBuilder(
 415                     ChoiceNodeImpl.class.getSimpleName());
 416             sb.append("[");
 417             sb.append("qname=" + qname);
 418             sb.append("]");
 419             return sb.toString();
 420         }
 421     }
 422
 423 }