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