Yang parser refactoring.
[yangtools.git] / 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<TypeDefinition<?>> typedefs = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
36     private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<>();
37     private final Set<GroupingDefinition> groupings = new TreeSet<>(Comparators.SCHEMA_NODE_COMP);
38     private final Set<GroupingBuilder> addedGroupings = new HashSet<>();
39
40     public ContainerSchemaNodeBuilder getInput() {
41         return inputBuilder;
42     }
43
44     public ContainerSchemaNodeBuilder getOutput() {
45         return outputBuilder;
46     }
47
48     RpcDefinitionBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
49         super(moduleName, line, qname);
50         this.schemaPath = path;
51         this.instance = new RpcDefinitionImpl(qname, path);
52     }
53
54     @Override
55     public RpcDefinition build() {
56         if (!isBuilt) {
57             final ContainerSchemaNode input = inputBuilder == null ? null : inputBuilder.build();
58             final ContainerSchemaNode output = outputBuilder == null ? null : outputBuilder.build();
59             instance.setInput(input);
60             instance.setOutput(output);
61
62             // TYPEDEFS
63             for (TypeDefinitionBuilder entry : addedTypedefs) {
64                 typedefs.add(entry.build());
65             }
66             instance.setTypeDefinitions(typedefs);
67
68             // GROUPINGS
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(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(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(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 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(ContainerSchemaNode input) {
235             this.input = input;
236         }
237
238         @Override
239         public ContainerSchemaNode getOutput() {
240             return output;
241         }
242
243         private void setOutput(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(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(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(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(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 }