yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/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.yangtools.yang.parser.builder.impl;
   9
  10 import java.util.ArrayList;
  11 import java.util.HashSet;
  12 import java.util.List;
  13 import java.util.Set;
  14 import java.util.TreeSet;
  15 import org.opendaylight.yangtools.yang.common.QName;
  16 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  17 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  18 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
  19 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  20 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  21 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  22 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  23 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  27 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
  28 import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
  29 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  30 import com.google.common.base.Preconditions;
  31 import com.google.common.collect.ImmutableList;
  32 import com.google.common.collect.ImmutableSet;
  33
  34 public final class ChoiceBuilder extends AbstractSchemaNodeBuilder implements DataSchemaNodeBuilder,
  35 AugmentationTargetBuilder {
  36     private ChoiceNodeImpl instance;
  37
  38     // DataSchemaNode args
  39     private boolean augmenting;
  40     private boolean addedByUses;
  41     private boolean configuration;
  42     private ChoiceNode originalNode;
  43     private ChoiceBuilder originalBuilder;
  44     private final ConstraintsBuilder constraints;
  45     // AugmentationTarget args
  46     private final Set<AugmentationSchema> augmentations = new HashSet<>();
  47     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  48     // ChoiceNode args
  49     private final Set<ChoiceCaseBuilder> caseBuilders = new HashSet<>();
  50     private String defaultCase;
  51
  52     public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  53         super(moduleName, line, qname);
  54         this.schemaPath = path;
  55         constraints = new ConstraintsBuilderImpl(moduleName, line);
  56     }
  57
  58     public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
  59             final ChoiceNode base) {
  60         super(moduleName, line, qname);
  61         this.schemaPath = path;
  62         constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
  63
  64         description = base.getDescription();
  65         reference = base.getReference();
  66         status = base.getStatus();
  67         augmenting = base.isAugmenting();
  68         addedByUses = base.isAddedByUses();
  69         originalNode =  base;
  70         configuration = base.isConfiguration();
  71         augmentations.addAll(base.getAvailableAugmentations());
  72
  73         Set<DataSchemaNodeBuilder> wrapped = BuilderUtils.wrapChildNodes(moduleName, line, new HashSet<DataSchemaNode>(
  74                 base.getCases()), path, qname);
  75         for (DataSchemaNodeBuilder wrap : wrapped) {
  76             if (wrap instanceof ChoiceCaseBuilder) {
  77                 caseBuilders.add((ChoiceCaseBuilder) wrap);
  78             }
  79         }
  80
  81         addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
  82                 qname));
  83     }
  84
  85     @Override
  86     public ChoiceNode build() {
  87         if (instance != null) {
  88             return instance;
  89         }
  90
  91         instance = new ChoiceNodeImpl(qname, schemaPath);
  92
  93         instance.description = description;
  94         instance.reference = reference;
  95         instance.status = status;
  96         instance.augmenting = augmenting;
  97         instance.addedByUses = addedByUses;
  98         instance.configuration = configuration;
  99
 100         instance.constraints = constraints.toInstance();
 101         instance.defaultCase = defaultCase;
 102
 103         // ORIGINAL NODE
 104         if (originalNode == null && originalBuilder != null) {
 105             originalNode = originalBuilder.build();
 106         }
 107         instance.original = originalNode;
 108
 109         // CASES
 110         final Set<ChoiceCaseNode> cases = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
 111         for (ChoiceCaseBuilder caseBuilder : caseBuilders) {
 112             cases.add(caseBuilder.build());
 113         }
 114         instance.cases = ImmutableSet.copyOf(cases);
 115
 116         // AUGMENTATIONS
 117         for (AugmentationSchemaBuilder builder : augmentationBuilders) {
 118             augmentations.add(builder.build());
 119         }
 120         instance.augmentations = ImmutableSet.copyOf(augmentations);
 121
 122         // UNKNOWN NODES
 123         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 124             unknownNodes.add(b.build());
 125         }
 126         instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
 127
 128         return instance;
 129     }
 130
 131     public Set<ChoiceCaseBuilder> getCases() {
 132         return caseBuilders;
 133     }
 134
 135     /**
 136      * Get case by name.
 137      *
 138      * @param caseName
 139      *            name of case to search
 140      * @return case with given name if present, null otherwise
 141      */
 142     public ChoiceCaseBuilder getCaseNodeByName(final String caseName) {
 143         for (ChoiceCaseBuilder addedCase : caseBuilders) {
 144             if (addedCase.getQName().getLocalName().equals(caseName)) {
 145                 return addedCase;
 146             }
 147         }
 148         return null;
 149     }
 150
 151     /**
 152      * Add case node to this choice.
 153      *
 154      * If node is not declared with 'case' keyword, create new case builder and
 155      * make this node child of newly created case.
 156      *
 157      * @param caseNode
 158      *            case node
 159      */
 160     public void addCase(final DataSchemaNodeBuilder caseNode) {
 161         QName caseQName = caseNode.getQName();
 162         String caseName = caseQName.getLocalName();
 163
 164         for (ChoiceCaseBuilder existingCase : caseBuilders) {
 165             if (existingCase.getQName().getLocalName().equals(caseName)) {
 166                 throw new YangParseException(caseNode.getModuleName(), caseNode.getLine(), "Can not add '" + caseNode
 167                         + "' to node '" + qname.getLocalName() + "' in module '" + getModuleName()
 168                         + "': case with same name already declared at line " + existingCase.getLine());
 169             }
 170         }
 171
 172         if (caseNode instanceof ChoiceCaseBuilder) {
 173             caseBuilders.add((ChoiceCaseBuilder) caseNode);
 174         } else {
 175             ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(caseNode.getModuleName(), caseNode.getLine(),
 176                     caseQName, caseNode.getPath());
 177             if (caseNode.isAugmenting()) {
 178                 // if node is added by augmentation, set case builder augmenting
 179                 // as true and node augmenting as false
 180                 caseBuilder.setAugmenting(true);
 181                 caseNode.setAugmenting(false);
 182             }
 183             SchemaPath newPath = caseNode.getPath().createChild(caseQName);
 184             caseNode.setPath(newPath);
 185             caseBuilder.addChildNode(caseNode);
 186             caseBuilders.add(caseBuilder);
 187         }
 188     }
 189
 190     @Override
 191     public boolean isAugmenting() {
 192         return augmenting;
 193     }
 194
 195     @Override
 196     public void setAugmenting(final boolean augmenting) {
 197         this.augmenting = augmenting;
 198     }
 199
 200     @Override
 201     public boolean isAddedByUses() {
 202         return addedByUses;
 203     }
 204
 205     @Override
 206     public void setAddedByUses(final boolean addedByUses) {
 207         this.addedByUses = addedByUses;
 208     }
 209
 210     @Override
 211     public ChoiceBuilder getOriginal() {
 212         return originalBuilder;
 213     }
 214
 215     @Override
 216     public void setOriginal(final SchemaNodeBuilder builder) {
 217         Preconditions.checkArgument(builder instanceof ChoiceBuilder, "Original of choice cannot be " + builder);
 218         this.originalBuilder = (ChoiceBuilder) builder;
 219     }
 220
 221     @Override
 222     public boolean isConfiguration() {
 223         return configuration;
 224     }
 225
 226     @Override
 227     public void setConfiguration(final boolean configuration) {
 228         this.configuration = configuration;
 229     }
 230
 231     @Override
 232     public ConstraintsBuilder getConstraints() {
 233         return constraints;
 234     }
 235
 236     @Override
 237     public void addAugmentation(final AugmentationSchemaBuilder augment) {
 238         augmentationBuilders.add(augment);
 239     }
 240
 241     public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
 242         return augmentationBuilders;
 243     }
 244
 245     public String getDefaultCase() {
 246         return defaultCase;
 247     }
 248
 249     public void setDefaultCase(final String defaultCase) {
 250         this.defaultCase = defaultCase;
 251     }
 252
 253     @Override
 254     public int hashCode() {
 255         final int prime = 31;
 256         int result = 1;
 257         result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
 258         return result;
 259     }
 260
 261     @Override
 262     public boolean equals(final Object obj) {
 263         if (this == obj) {
 264             return true;
 265         }
 266         if (obj == null) {
 267             return false;
 268         }
 269         if (getClass() != obj.getClass()) {
 270             return false;
 271         }
 272         ChoiceBuilder other = (ChoiceBuilder) obj;
 273         if (schemaPath == null) {
 274             if (other.schemaPath != null) {
 275                 return false;
 276             }
 277         } else if (!schemaPath.equals(other.schemaPath)) {
 278             return false;
 279         }
 280         if (getParent() == null) {
 281             if (other.getParent() != null) {
 282                 return false;
 283             }
 284         } else if (!getParent().equals(other.getParent())) {
 285             return false;
 286         }
 287         return true;
 288     }
 289
 290     @Override
 291     public String toString() {
 292         return "choice " + qname.getLocalName();
 293     }
 294
 295 }