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