opendaylight/sal/yang-prototype/code-generator/yang-model-parser-impl/src/main/java/org/opendaylight/controller/yang/model/parser/builder/impl/RpcDefinitionBuilder.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.HashSet;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.opendaylight.controller.yang.common.QName;
  17 import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
  18 import org.opendaylight.controller.yang.model.api.GroupingDefinition;
  19 import org.opendaylight.controller.yang.model.api.RpcDefinition;
  20 import org.opendaylight.controller.yang.model.api.SchemaPath;
  21 import org.opendaylight.controller.yang.model.api.Status;
  22 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  23 import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
  24 import org.opendaylight.controller.yang.model.parser.builder.api.GroupingBuilder;
  25 import org.opendaylight.controller.yang.model.parser.builder.api.SchemaNodeBuilder;
  26 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionAwareBuilder;
  27 import org.opendaylight.controller.yang.model.parser.builder.api.TypeDefinitionBuilder;
  28
  29 public class RpcDefinitionBuilder implements SchemaNodeBuilder,
  30         TypeDefinitionAwareBuilder {
  31     private final RpcDefinitionImpl instance;
  32     private final QName qname;
  33     private SchemaPath schemaPath;
  34     private ContainerSchemaNodeBuilder inputBuilder;
  35     private ContainerSchemaNodeBuilder outputBuilder;
  36     private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
  37     private final Set<GroupingBuilder> addedGroupings = new HashSet<GroupingBuilder>();
  38     private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
  39
  40     RpcDefinitionBuilder(final QName qname) {
  41         this.qname = qname;
  42         this.instance = new RpcDefinitionImpl(qname);
  43     }
  44
  45     @Override
  46     public RpcDefinition build() {
  47         final ContainerSchemaNode input = inputBuilder.build();
  48         final ContainerSchemaNode output = outputBuilder.build();
  49         instance.setInput(input);
  50         instance.setOutput(output);
  51
  52         instance.setPath(schemaPath);
  53
  54         // TYPEDEFS
  55         final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
  56         for (TypeDefinitionBuilder entry : addedTypedefs) {
  57             typedefs.add(entry.build());
  58         }
  59         instance.setTypeDefinitions(typedefs);
  60
  61         // GROUPINGS
  62         final Set<GroupingDefinition> groupings = new HashSet<GroupingDefinition>();
  63         for (GroupingBuilder entry : addedGroupings) {
  64             groupings.add(entry.build());
  65         }
  66         instance.setGroupings(groupings);
  67
  68         // UNKNOWN NODES
  69         final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
  70         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
  71             unknownNodes.add(b.build());
  72         }
  73         instance.setUnknownSchemaNodes(unknownNodes);
  74
  75         return instance;
  76     }
  77
  78     void setInput(final ContainerSchemaNodeBuilder inputBuilder) {
  79         this.inputBuilder = inputBuilder;
  80     }
  81
  82     void setOutput(final ContainerSchemaNodeBuilder outputBuilder) {
  83         this.outputBuilder = outputBuilder;
  84     }
  85
  86     @Override
  87     public void addTypedef(final TypeDefinitionBuilder type) {
  88         addedTypedefs.add(type);
  89     }
  90
  91     @Override
  92     public SchemaPath getPath() {
  93         return schemaPath;
  94     }
  95
  96     @Override
  97     public void setPath(SchemaPath schemaPath) {
  98         this.schemaPath = schemaPath;
  99     }
 100
 101     @Override
 102     public void setDescription(final String description) {
 103         instance.setDescription(description);
 104     }
 105
 106     @Override
 107     public void setReference(final String reference) {
 108         instance.setReference(reference);
 109     }
 110
 111     @Override
 112     public void setStatus(final Status status) {
 113         instance.setStatus(status);
 114     }
 115
 116     @Override
 117     public QName getQName() {
 118         return null;
 119     }
 120
 121     @Override
 122     public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
 123         addedUnknownNodes.add(unknownNode);
 124     }
 125
 126     @Override
 127     public int hashCode() {
 128         return qname.hashCode();
 129     }
 130
 131     @Override
 132     public boolean equals(Object obj) {
 133         if (obj == null) {
 134             return false;
 135         }
 136         if (!(obj instanceof RpcDefinitionBuilder)) {
 137             return false;
 138         }
 139         final RpcDefinitionBuilder other = (RpcDefinitionBuilder) obj;
 140         if (other.qname == null) {
 141             if (this.qname != null) {
 142                 return false;
 143             }
 144         } else if (!other.qname.equals(this.qname)) {
 145             return false;
 146         }
 147         return true;
 148     }
 149
 150     private static class RpcDefinitionImpl implements RpcDefinition {
 151
 152         private final QName qname;
 153         private SchemaPath path;
 154         private String description;
 155         private String reference;
 156         private Status status;
 157         private ContainerSchemaNode input;
 158         private ContainerSchemaNode output;
 159         private Set<TypeDefinition<?>> typeDefinitions;
 160         private Set<GroupingDefinition> groupings;
 161         private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
 162
 163         private RpcDefinitionImpl(final QName qname) {
 164             this.qname = qname;
 165         }
 166
 167         @Override
 168         public QName getQName() {
 169             return qname;
 170         }
 171
 172         @Override
 173         public SchemaPath getPath() {
 174             return path;
 175         }
 176
 177         private void setPath(SchemaPath path) {
 178             this.path = path;
 179         }
 180
 181         @Override
 182         public String getDescription() {
 183             return description;
 184         }
 185
 186         private void setDescription(String description) {
 187             this.description = description;
 188         }
 189
 190         @Override
 191         public String getReference() {
 192             return reference;
 193         }
 194
 195         private void setReference(String reference) {
 196             this.reference = reference;
 197         }
 198
 199         @Override
 200         public Status getStatus() {
 201             return status;
 202         }
 203
 204         private void setStatus(Status status) {
 205             this.status = status;
 206         }
 207
 208         @Override
 209         public ContainerSchemaNode getInput() {
 210             return input;
 211         }
 212
 213         private void setInput(ContainerSchemaNode input) {
 214             this.input = input;
 215         }
 216
 217         @Override
 218         public ContainerSchemaNode getOutput() {
 219             return output;
 220         }
 221
 222         private void setOutput(ContainerSchemaNode output) {
 223             this.output = output;
 224         }
 225
 226         @Override
 227         public Set<TypeDefinition<?>> getTypeDefinitions() {
 228             return typeDefinitions;
 229         }
 230
 231         private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
 232             this.typeDefinitions = typeDefinitions;
 233         }
 234
 235         @Override
 236         public Set<GroupingDefinition> getGroupings() {
 237             return groupings;
 238         }
 239
 240         private void setGroupings(Set<GroupingDefinition> groupings) {
 241             this.groupings = groupings;
 242         }
 243
 244         @Override
 245         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 246             return unknownNodes;
 247         }
 248
 249         private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
 250             if (unknownNodes != null) {
 251                 this.unknownNodes = unknownNodes;
 252             }
 253         }
 254
 255         @Override
 256         public int hashCode() {
 257             final int prime = 31;
 258             int result = 1;
 259             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 260             return result;
 261         }
 262
 263         @Override
 264         public boolean equals(Object obj) {
 265             if (this == obj) {
 266                 return true;
 267             }
 268             if (obj == null) {
 269                 return false;
 270             }
 271             if (getClass() != obj.getClass()) {
 272                 return false;
 273             }
 274             final RpcDefinitionImpl other = (RpcDefinitionImpl) obj;
 275             if (qname == null) {
 276                 if (other.qname != null) {
 277                     return false;
 278                 }
 279             } else if (!qname.equals(other.qname)) {
 280                 return false;
 281             }
 282             return true;
 283         }
 284
 285         @Override
 286         public String toString() {
 287             StringBuilder sb = new StringBuilder(
 288                     RpcDefinitionImpl.class.getSimpleName() + "[");
 289             sb.append("qname=" + qname);
 290             sb.append(", path=" + path);
 291             sb.append(", input=" + input);
 292             sb.append(", output=" + output + "]");
 293             return sb.toString();
 294         }
 295     }
 296
 297 }