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