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