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