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

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