opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/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.model.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.model.parser.builder.api.AbstractChildNodeBuilder;
  30 import org.opendaylight.controller.yang.model.parser.builder.api.AugmentationTargetBuilder;
  31 import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;
  32 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;
  33 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionAwareBuilder;
  34 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
  35 import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
  36
  37 public class ContainerSchemaNodeBuilder extends AbstractChildNodeBuilder
  38         implements TypeDefinitionAwareBuilder, AugmentationTargetBuilder,
  39         DataSchemaNodeBuilder {
  40
  41     private final ContainerSchemaNodeImpl instance;
  42     private final ConstraintsBuilder constraintsBuilder;
  43
  44     private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
  45     private final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
  46     private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
  47     private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
  48
  49     ContainerSchemaNodeBuilder(QName qname) {
  50         super(qname);
  51         instance = new ContainerSchemaNodeImpl(qname);
  52         constraintsBuilder = new ConstraintsBuilder();
  53     }
  54
  55     @Override
  56     public ContainerSchemaNode build() {
  57         // CHILD NODES
  58         Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
  59         for (DataSchemaNodeBuilder node : childNodes) {
  60             childs.put(node.getQName(), node.build());
  61         }
  62         instance.setChildNodes(childs);
  63
  64         // GROUPINGS
  65         Set<GroupingDefinition> groupingDefinitions = new HashSet<GroupingDefinition>();
  66         for (GroupingBuilder builder : groupings) {
  67             groupingDefinitions.add(builder.build());
  68         }
  69         instance.setGroupings(groupingDefinitions);
  70
  71         // TYPEDEFS
  72         Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
  73         for (TypeDefinitionBuilder entry : addedTypedefs) {
  74             typedefs.add(entry.build());
  75         }
  76         instance.setTypeDefinitions(typedefs);
  77
  78         // USES
  79         Set<UsesNode> uses = new HashSet<UsesNode>();
  80         for (UsesNodeBuilder builder : addedUsesNodes) {
  81             uses.add(builder.build());
  82         }
  83         instance.setUses(uses);
  84
  85         // UNKNOWN NODES
  86         final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
  87         for(UnknownSchemaNodeBuilder b : addedUnknownNodes) {
  88             unknownNodes.add(b.build());
  89         }
  90         instance.setUnknownSchemaNodes(unknownNodes);
  91
  92         instance.setConstraints(constraintsBuilder.build());
  93         instance.setAvailableAugmentations(augmentations);
  94
  95         return instance;
  96     }
  97
  98     @Override
  99     public void addTypedef(TypeDefinitionBuilder type) {
 100         addedTypedefs.add(type);
 101     }
 102
 103     @Override
 104     public void addAugmentation(AugmentationSchema augment) {
 105         augmentations.add(augment);
 106     }
 107
 108     @Override
 109     public void setPath(SchemaPath schemaPath) {
 110         instance.setPath(schemaPath);
 111     }
 112
 113     @Override
 114     public void setDescription(String description) {
 115         instance.setDescription(description);
 116     }
 117
 118     @Override
 119     public void setReference(String reference) {
 120         instance.setReference(reference);
 121     }
 122
 123     @Override
 124     public void setStatus(Status status) {
 125         instance.setStatus(status);
 126     }
 127
 128     @Override
 129     public void setAugmenting(boolean augmenting) {
 130         instance.setAugmenting(augmenting);
 131     }
 132
 133     @Override
 134     public void setConfiguration(boolean configuration) {
 135         instance.setConfiguration(configuration);
 136     }
 137
 138     @Override
 139     public ConstraintsBuilder getConstraintsBuilder() {
 140         return constraintsBuilder;
 141     }
 142
 143     @Override
 144     public void addUsesNode(UsesNodeBuilder usesNodeBuilder) {
 145         addedUsesNodes.add(usesNodeBuilder);
 146     }
 147
 148     public void setPresenceContainer(boolean presence) {
 149         instance.setPresenceContainer(presence);
 150     }
 151
 152     @Override
 153     public void addUnknownSchemaNode(UnknownSchemaNodeBuilder unknownSchemaNodeBuilder) {
 154         addedUnknownNodes.add(unknownSchemaNodeBuilder);
 155     }
 156
 157     private class ContainerSchemaNodeImpl implements ContainerSchemaNode {
 158
 159         private final QName qname;
 160         private SchemaPath path;
 161         private String description;
 162         private String reference;
 163         private Status status = Status.CURRENT;
 164         private boolean augmenting;
 165         private boolean configuration;
 166         private ConstraintDefinition constraints;
 167         private Set<AugmentationSchema> augmentations = Collections.emptySet();
 168         private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
 169         private Set<GroupingDefinition> groupings = Collections.emptySet();
 170         private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
 171         private Set<UsesNode> uses = Collections.emptySet();
 172         private List<UnknownSchemaNode> unknownSchemaNodes = Collections.emptyList();
 173         private boolean presence;
 174
 175         private ContainerSchemaNodeImpl(QName qname) {
 176             this.qname = qname;
 177         }
 178
 179         @Override
 180         public QName getQName() {
 181             return qname;
 182         }
 183
 184         @Override
 185         public SchemaPath getPath() {
 186             return path;
 187         }
 188
 189         private void setPath(SchemaPath path) {
 190             this.path = path;
 191         }
 192
 193         @Override
 194         public String getDescription() {
 195             return description;
 196         }
 197
 198         private void setDescription(String description) {
 199             this.description = description;
 200         }
 201
 202         @Override
 203         public String getReference() {
 204             return reference;
 205         }
 206
 207         private void setReference(String reference) {
 208             this.reference = reference;
 209         }
 210
 211         @Override
 212         public Status getStatus() {
 213             return status;
 214         }
 215
 216         private void setStatus(Status status) {
 217             if(status != null) {
 218                 this.status = status;
 219             }
 220         }
 221
 222         @Override
 223         public boolean isAugmenting() {
 224             return augmenting;
 225         }
 226
 227         private void setAugmenting(boolean augmenting) {
 228             this.augmenting = augmenting;
 229         }
 230
 231         @Override
 232         public boolean isConfiguration() {
 233             return configuration;
 234         }
 235
 236         private void setConfiguration(boolean configuration) {
 237             this.configuration = configuration;
 238         }
 239
 240         @Override
 241         public ConstraintDefinition getConstraints() {
 242             return constraints;
 243         }
 244
 245         private void setConstraints(ConstraintDefinition constraints) {
 246             this.constraints = constraints;
 247         }
 248
 249         @Override
 250         public Set<AugmentationSchema> getAvailableAugmentations() {
 251             return augmentations;
 252         }
 253
 254         private void setAvailableAugmentations(
 255                 Set<AugmentationSchema> augmentations) {
 256             if (augmentations != null) {
 257                 this.augmentations = augmentations;
 258             }
 259         }
 260
 261         @Override
 262         public Set<DataSchemaNode> getChildNodes() {
 263             return new HashSet<DataSchemaNode>(childNodes.values());
 264         }
 265
 266         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
 267             if (childNodes != null) {
 268                 this.childNodes = childNodes;
 269             }
 270         }
 271
 272         @Override
 273         public Set<GroupingDefinition> getGroupings() {
 274             return groupings;
 275         }
 276
 277         private void setGroupings(Set<GroupingDefinition> groupings) {
 278             if (groupings != null) {
 279                 this.groupings = groupings;
 280             }
 281         }
 282
 283         @Override
 284         public DataSchemaNode getDataChildByName(QName name) {
 285             return childNodes.get(name);
 286         }
 287
 288         @Override
 289         public DataSchemaNode getDataChildByName(String name) {
 290             DataSchemaNode result = null;
 291             for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
 292                 if (entry.getKey().getLocalName().equals(name)) {
 293                     result = entry.getValue();
 294                     break;
 295                 }
 296             }
 297             return result;
 298         }
 299
 300         @Override
 301         public Set<UsesNode> getUses() {
 302             return uses;
 303         }
 304
 305         private void setUses(Set<UsesNode> uses) {
 306             if (uses != null) {
 307                 this.uses = uses;
 308             }
 309         }
 310
 311         @Override
 312         public boolean isPresenceContainer() {
 313             return presence;
 314         }
 315
 316         private void setPresenceContainer(boolean presence) {
 317             this.presence = presence;
 318         }
 319
 320         @Override
 321         public Set<TypeDefinition<?>> getTypeDefinitions() {
 322             return typeDefinitions;
 323         }
 324
 325         private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
 326             if (typeDefinitions != null) {
 327                 this.typeDefinitions = typeDefinitions;
 328             }
 329         }
 330
 331         @Override
 332         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 333             return unknownSchemaNodes;
 334         }
 335
 336         private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownSchemaNodes) {
 337             if(unknownSchemaNodes != null) {
 338                 this.unknownSchemaNodes = unknownSchemaNodes;
 339             }
 340         }
 341
 342         @Override
 343         public int hashCode() {
 344             final int prime = 31;
 345             int result = 1;
 346             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 347             result = prime * result + ((path == null) ? 0 : path.hashCode());
 348             return result;
 349         }
 350
 351         @Override
 352         public boolean equals(Object obj) {
 353             if (this == obj) {
 354                 return true;
 355             }
 356             if (obj == null) {
 357                 return false;
 358             }
 359             if (getClass() != obj.getClass()) {
 360                 return false;
 361             }
 362             ContainerSchemaNodeImpl other = (ContainerSchemaNodeImpl) obj;
 363             if (qname == null) {
 364                 if (other.qname != null) {
 365                     return false;
 366                 }
 367             } else if (!qname.equals(other.qname)) {
 368                 return false;
 369             }
 370             if (path == null) {
 371                 if (other.path != null) {
 372                     return false;
 373                 }
 374             } else if (!path.equals(other.path)) {
 375                 return false;
 376             }
 377             return true;
 378         }
 379
 380         @Override
 381         public String toString() {
 382             StringBuilder sb = new StringBuilder(
 383                     ContainerSchemaNodeImpl.class.getSimpleName());
 384             sb.append("[");
 385             sb.append("qname=" + qname);
 386             sb.append("]");
 387             return sb.toString();
 388         }
 389     }
 390
 391 }