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