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