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