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