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