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