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