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