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