yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ChoiceCaseBuilder.java

   1 /*
   2  * Copyright (c) 2014 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.net.URI;
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.Date;
  14 import java.util.List;
  15 import java.util.Set;
  16
  17 import org.opendaylight.yangtools.yang.common.QName;
  18 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  19 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
  20 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
  21 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  22 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  24 import org.opendaylight.yangtools.yang.model.api.Status;
  25 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  27 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  28 import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
  29 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  30 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  31 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  32 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  33 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  34 import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
  35 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  36
  37 import com.google.common.base.Preconditions;
  38 import com.google.common.collect.ImmutableList;
  39 import com.google.common.collect.ImmutableSet;
  40
  41 public final class ChoiceCaseBuilder extends AbstractDataNodeContainerBuilder implements DataSchemaNodeBuilder,
  42         AugmentationTargetBuilder {
  43     private ChoiceCaseNodeImpl instance;
  44     // SchemaNode args
  45     private SchemaPath schemaPath;
  46     private String description;
  47     private String reference;
  48     private Status status = Status.CURRENT;
  49     // DataSchemaNode args
  50     private boolean augmenting;
  51     private boolean addedByUses;
  52     private final ConstraintsBuilder constraints;
  53     // AugmentationTarget args
  54     private final List<AugmentationSchema> augmentations = new ArrayList<>();
  55     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  56
  57     public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  58         super(moduleName, line, qname);
  59         this.schemaPath = path;
  60         constraints = new ConstraintsBuilder(moduleName, line);
  61     }
  62
  63     public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
  64             final ChoiceCaseNode base) {
  65         super(moduleName, line, qname);
  66         this.schemaPath = path;
  67         constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
  68
  69         description = base.getDescription();
  70         reference = base.getReference();
  71         status = base.getStatus();
  72         augmenting = base.isAugmenting();
  73         addedByUses = base.isAddedByUses();
  74
  75         URI ns = qname.getNamespace();
  76         Date rev = qname.getRevision();
  77         String pref = qname.getPrefix();
  78         addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
  79         addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
  80         addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
  81                 rev, pref));
  82
  83         augmentations.addAll(base.getAvailableAugmentations());
  84         usesNodes.addAll(base.getUses());
  85     }
  86
  87     @Override
  88     public ChoiceCaseNode build() {
  89         if (instance != null) {
  90             return instance;
  91         }
  92
  93         instance = new ChoiceCaseNodeImpl(qname, schemaPath);
  94
  95         instance.description = description;
  96         instance.reference = reference;
  97         instance.status = status;
  98         instance.augmenting = augmenting;
  99         instance.addedByUses = addedByUses;
 100
 101         instance.constraints = constraints.build();
 102
 103         // CHILD NODES
 104         for (DataSchemaNodeBuilder node : addedChildNodes) {
 105             childNodes.put(node.getQName(), node.build());
 106         }
 107         instance.childNodes = ImmutableSet.copyOf(childNodes.values());
 108
 109         // USES
 110         for (UsesNodeBuilder builder : addedUsesNodes) {
 111             usesNodes.add(builder.build());
 112         }
 113         instance.uses = ImmutableSet.copyOf(usesNodes);
 114
 115         // UNKNOWN NODES
 116         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 117             unknownNodes.add(b.build());
 118         }
 119         instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
 120
 121         // AUGMENTATIONS
 122         for (AugmentationSchemaBuilder builder : augmentationBuilders) {
 123             augmentations.add(builder.build());
 124         }
 125         instance.augmentations = ImmutableSet.copyOf(augmentations);
 126
 127         return instance;
 128     }
 129
 130     @Override
 131     public SchemaPath getPath() {
 132         return schemaPath;
 133     }
 134
 135     @Override
 136     public void setPath(final SchemaPath path) {
 137         this.schemaPath = path;
 138     }
 139
 140     @Override
 141     public String getDescription() {
 142         return description;
 143     }
 144
 145     @Override
 146     public void setDescription(final String description) {
 147         this.description = description;
 148     }
 149
 150     @Override
 151     public String getReference() {
 152         return reference;
 153     }
 154
 155     @Override
 156     public void setReference(final String reference) {
 157         this.reference = reference;
 158     }
 159
 160     @Override
 161     public Status getStatus() {
 162         return status;
 163     }
 164
 165     @Override
 166     public void setStatus(final Status status) {
 167         this.status = Preconditions.checkNotNull(status, "status cannot be null");
 168     }
 169
 170     @Override
 171     public boolean isAugmenting() {
 172         return augmenting;
 173     }
 174
 175     @Override
 176     public void setAugmenting(final boolean augmenting) {
 177         this.augmenting = augmenting;
 178     }
 179
 180     @Override
 181     public boolean isAddedByUses() {
 182         return addedByUses;
 183     }
 184
 185     @Override
 186     public void setAddedByUses(final boolean addedByUses) {
 187         this.addedByUses = addedByUses;
 188     }
 189
 190     @Override
 191     public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
 192         return Collections.emptySet();
 193     }
 194
 195     @Override
 196     public void addTypedef(final TypeDefinitionBuilder typedefBuilder) {
 197         throw new YangParseException(getModuleName(), typedefBuilder.getLine(), "Can not add type definition to choice case.");
 198     }
 199
 200     @Override
 201     public boolean isConfiguration() {
 202         return false;
 203     }
 204
 205     @Override
 206     public void setConfiguration(final boolean configuration) {
 207         throw new YangParseException(getModuleName(), getLine(), "Can not add config statement to choice case.");
 208     }
 209
 210     @Override
 211     public ConstraintsBuilder getConstraints() {
 212         return constraints;
 213     }
 214
 215     @Override
 216     public void addAugmentation(final AugmentationSchemaBuilder augment) {
 217         augmentationBuilders.add(augment);
 218     }
 219
 220     @Override
 221     public int hashCode() {
 222         final int prime = 31;
 223         int result = 1;
 224         result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
 225         return result;
 226     }
 227
 228     @Override
 229     public boolean equals(final Object obj) {
 230         if (this == obj) {
 231             return true;
 232         }
 233         if (obj == null) {
 234             return false;
 235         }
 236         if (getClass() != obj.getClass()) {
 237             return false;
 238         }
 239         ChoiceCaseBuilder other = (ChoiceCaseBuilder) obj;
 240         if (schemaPath == null) {
 241             if (other.schemaPath != null) {
 242                 return false;
 243             }
 244         } else if (!schemaPath.equals(other.schemaPath)) {
 245             return false;
 246         }
 247         if (getParent() == null) {
 248             if (other.getParent() != null) {
 249                 return false;
 250             }
 251         } else if (!getParent().equals(other.getParent())) {
 252             return false;
 253         }
 254         return true;
 255     }
 256
 257     @Override
 258     public String toString() {
 259         return "case " + getQName().getLocalName();
 260     }
 261
 262     private static final class ChoiceCaseNodeImpl implements ChoiceCaseNode {
 263         private final QName qname;
 264         private final SchemaPath path;
 265         private String description;
 266         private String reference;
 267         private Status status = Status.CURRENT;
 268         private boolean augmenting;
 269         private boolean addedByUses;
 270         private ConstraintDefinition constraints;
 271         private ImmutableSet<DataSchemaNode> childNodes;
 272         private ImmutableSet<AugmentationSchema> augmentations;
 273         private ImmutableSet<UsesNode> uses;
 274         private ImmutableList<UnknownSchemaNode> unknownNodes;
 275
 276         private ChoiceCaseNodeImpl(final QName qname, final SchemaPath path) {
 277             this.qname = qname;
 278             this.path = path;
 279         }
 280
 281         @Override
 282         public QName getQName() {
 283             return qname;
 284         }
 285
 286         @Override
 287         public SchemaPath getPath() {
 288             return path;
 289         }
 290
 291         @Override
 292         public String getDescription() {
 293             return description;
 294         }
 295
 296         @Override
 297         public String getReference() {
 298             return reference;
 299         }
 300
 301         @Override
 302         public Status getStatus() {
 303             return status;
 304         }
 305
 306         @Override
 307         public boolean isConfiguration() {
 308             return false;
 309         }
 310
 311         @Override
 312         public ConstraintDefinition getConstraints() {
 313             return constraints;
 314         }
 315
 316         @Override
 317         public boolean isAugmenting() {
 318             return augmenting;
 319         }
 320
 321         @Override
 322         public boolean isAddedByUses() {
 323             return addedByUses;
 324         }
 325
 326         @Override
 327         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 328             return unknownNodes;
 329         }
 330
 331         /**
 332          * Always returns an empty set, because case node can not contains type
 333          * definitions.
 334          */
 335         @Override
 336         public Set<TypeDefinition<?>> getTypeDefinitions() {
 337             return Collections.emptySet();
 338         }
 339
 340         @Override
 341         public Set<DataSchemaNode> getChildNodes() {
 342             return childNodes;
 343         }
 344
 345         @Override
 346         public Set<GroupingDefinition> getGroupings() {
 347             return Collections.emptySet();
 348         }
 349
 350         @Override
 351         public DataSchemaNode getDataChildByName(final QName name) {
 352             return getChildNode(childNodes, name);
 353         }
 354
 355         @Override
 356         public DataSchemaNode getDataChildByName(final String name) {
 357             return getChildNode(childNodes, name);
 358         }
 359
 360         @Override
 361         public Set<UsesNode> getUses() {
 362             return uses;
 363         }
 364
 365         @Override
 366         public Set<AugmentationSchema> getAvailableAugmentations() {
 367             return augmentations;
 368         }
 369
 370         @Override
 371         public int hashCode() {
 372             final int prime = 31;
 373             int result = 1;
 374             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 375             result = prime * result + ((path == null) ? 0 : path.hashCode());
 376             return result;
 377         }
 378
 379         @Override
 380         public boolean equals(final Object obj) {
 381             if (this == obj) {
 382                 return true;
 383             }
 384             if (obj == null) {
 385                 return false;
 386             }
 387             if (getClass() != obj.getClass()) {
 388                 return false;
 389             }
 390             ChoiceCaseNodeImpl other = (ChoiceCaseNodeImpl) obj;
 391             if (qname == null) {
 392                 if (other.qname != null) {
 393                     return false;
 394                 }
 395             } else if (!qname.equals(other.qname)) {
 396                 return false;
 397             }
 398             if (path == null) {
 399                 if (other.path != null) {
 400                     return false;
 401                 }
 402             } else if (!path.equals(other.path)) {
 403                 return false;
 404             }
 405             return true;
 406         }
 407
 408         @Override
 409         public String toString() {
 410             StringBuilder sb = new StringBuilder(ChoiceCaseNodeImpl.class.getSimpleName());
 411             sb.append("[");
 412             sb.append("qname=");
 413             sb.append(qname);
 414             sb.append("]");
 415             return sb.toString();
 416         }
 417     }
 418
 419 }