2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.controller.yang.parser.util;
10 import static org.opendaylight.controller.yang.parser.util.ParserUtils.*;
12 import java.lang.reflect.Method;
13 import java.util.List;
15 import org.opendaylight.controller.yang.model.api.AnyXmlSchemaNode;
16 import org.opendaylight.controller.yang.model.api.ChoiceNode;
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.LeafListSchemaNode;
20 import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
21 import org.opendaylight.controller.yang.model.api.ListSchemaNode;
22 import org.opendaylight.controller.yang.model.api.MustDefinition;
23 import org.opendaylight.controller.yang.model.api.TypeDefinition;
24 import org.opendaylight.controller.yang.model.util.ExtendedType;
25 import org.opendaylight.controller.yang.parser.builder.api.Builder;
26 import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
27 import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
28 import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
29 import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
30 import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
31 import org.opendaylight.controller.yang.parser.builder.impl.ChoiceBuilder;
32 import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
33 import org.opendaylight.controller.yang.parser.builder.impl.GroupingBuilderImpl;
34 import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
35 import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
36 import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
37 import org.opendaylight.controller.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
38 import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
41 * Utility class with helper methods to perform operations tied to refine
44 public class RefineUtils {
46 private RefineUtils() {
50 * Find original builder of node to refine and return copy of this builder.
52 * We must create and use a copy of builder to preserve original builder
53 * state, because this object will be refined (modified) and later added to
54 * {@link UsesNodeBuilder}.
57 * @param targetGrouping
58 * builder of grouping which should contains node to refine
60 * refine object containing informations about refine
65 public static SchemaNodeBuilder getRefineNodeFromGroupingBuilder(final GroupingBuilder targetGrouping,
66 final RefineHolder refine, final String moduleName) {
67 Builder result = null;
68 final Builder lookedUpBuilder = findRefineTargetBuilder(targetGrouping, refine.getName());
69 if (lookedUpBuilder instanceof LeafSchemaNodeBuilder) {
70 result = new LeafSchemaNodeBuilder((LeafSchemaNodeBuilder) lookedUpBuilder);
71 } else if (lookedUpBuilder instanceof ContainerSchemaNodeBuilder) {
72 result = new ContainerSchemaNodeBuilder((ContainerSchemaNodeBuilder) lookedUpBuilder);
73 } else if (lookedUpBuilder instanceof ListSchemaNodeBuilder) {
74 result = new ListSchemaNodeBuilder((ListSchemaNodeBuilder) lookedUpBuilder);
75 } else if (lookedUpBuilder instanceof LeafListSchemaNodeBuilder) {
76 result = new LeafListSchemaNodeBuilder((LeafListSchemaNodeBuilder) lookedUpBuilder);
77 } else if (lookedUpBuilder instanceof ChoiceBuilder) {
78 result = new ChoiceBuilder((ChoiceBuilder) lookedUpBuilder);
79 } else if (lookedUpBuilder instanceof AnyXmlBuilder) {
80 result = new AnyXmlBuilder((AnyXmlBuilder) lookedUpBuilder);
81 } else if (lookedUpBuilder instanceof GroupingBuilder) {
82 result = new GroupingBuilderImpl((GroupingBuilder) lookedUpBuilder);
83 } else if (lookedUpBuilder instanceof TypeDefinitionBuilder) {
84 result = new TypeDefinitionBuilderImpl((TypeDefinitionBuilder) lookedUpBuilder);
86 throw new YangParseException(moduleName, refine.getLine(), "Target '" + refine.getName()
87 + "' can not be refined");
89 return (SchemaNodeBuilder) result;
93 * Create builder object from refine target node.
96 * grouping which should contains node to refine
98 * refine object containing informations about refine
100 * current module name
103 public static SchemaNodeBuilder getRefineNodeFromGroupingDefinition(final GroupingDefinition grouping,
104 final RefineHolder refine, final String moduleName) {
105 SchemaNodeBuilder result = null;
106 final int line = refine.getLine();
107 final Object lookedUpNode = findRefineTargetNode(grouping, refine.getName());
108 if (lookedUpNode instanceof LeafSchemaNode) {
109 result = createLeafBuilder((LeafSchemaNode) lookedUpNode, line);
110 } else if (lookedUpNode instanceof ContainerSchemaNode) {
111 result = createContainer((ContainerSchemaNode) lookedUpNode, line);
112 } else if (lookedUpNode instanceof ListSchemaNode) {
113 result = createList((ListSchemaNode) lookedUpNode, line);
114 } else if (lookedUpNode instanceof LeafListSchemaNode) {
115 result = createLeafList((LeafListSchemaNode) lookedUpNode, line);
116 } else if (lookedUpNode instanceof ChoiceNode) {
117 result = createChoice((ChoiceNode) lookedUpNode, line);
118 } else if (lookedUpNode instanceof AnyXmlSchemaNode) {
119 result = createAnyXml((AnyXmlSchemaNode) lookedUpNode, line);
120 } else if (lookedUpNode instanceof GroupingDefinition) {
121 result = createGrouping((GroupingDefinition) lookedUpNode, line);
122 } else if (lookedUpNode instanceof TypeDefinition) {
123 result = createTypedef((ExtendedType) lookedUpNode, line);
125 throw new YangParseException(moduleName, line, "Target '" + refine.getName() + "' can not be refined");
130 public static void refineLeaf(LeafSchemaNodeBuilder leaf, RefineHolder refine, int line) {
131 String defaultStr = refine.getDefaultStr();
132 Boolean mandatory = refine.isMandatory();
133 MustDefinition must = refine.getMust();
134 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
136 if (defaultStr != null && !("".equals(defaultStr))) {
137 leaf.setDefaultStr(defaultStr);
139 if (mandatory != null) {
140 leaf.getConstraints().setMandatory(mandatory);
143 leaf.getConstraints().addMustDefinition(must);
145 if (unknownNodes != null) {
146 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
147 leaf.addUnknownNodeBuilder(unknown);
152 public static void refineContainer(ContainerSchemaNodeBuilder container, RefineHolder refine, int line) {
153 Boolean presence = refine.isPresence();
154 MustDefinition must = refine.getMust();
155 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
157 if (presence != null) {
158 container.setPresence(presence);
161 container.getConstraints().addMustDefinition(must);
163 if (unknownNodes != null) {
164 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
165 container.addUnknownNodeBuilder(unknown);
170 public static void refineList(ListSchemaNodeBuilder list, RefineHolder refine, int line) {
171 MustDefinition must = refine.getMust();
172 Integer min = refine.getMinElements();
173 Integer max = refine.getMaxElements();
174 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
177 list.getConstraints().addMustDefinition(must);
180 list.getConstraints().setMinElements(min);
183 list.getConstraints().setMaxElements(max);
185 if (unknownNodes != null) {
186 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
187 list.addUnknownNodeBuilder(unknown);
192 public static void refineLeafList(LeafListSchemaNodeBuilder leafList, RefineHolder refine, int line) {
193 MustDefinition must = refine.getMust();
194 Integer min = refine.getMinElements();
195 Integer max = refine.getMaxElements();
196 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
199 leafList.getConstraints().addMustDefinition(must);
202 leafList.getConstraints().setMinElements(min);
205 leafList.getConstraints().setMaxElements(max);
207 if (unknownNodes != null) {
208 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
209 leafList.addUnknownNodeBuilder(unknown);
214 public static void refineChoice(ChoiceBuilder choice, RefineHolder refine, int line) {
215 String defaultStr = refine.getDefaultStr();
216 Boolean mandatory = refine.isMandatory();
217 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
219 if (defaultStr != null) {
220 choice.setDefaultCase(defaultStr);
222 if (mandatory != null) {
223 choice.getConstraints().setMandatory(mandatory);
225 if (unknownNodes != null) {
226 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
227 choice.addUnknownNodeBuilder(unknown);
232 public static void refineAnyxml(AnyXmlBuilder anyXml, RefineHolder refine, int line) {
233 Boolean mandatory = refine.isMandatory();
234 MustDefinition must = refine.getMust();
235 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
237 if (mandatory != null) {
238 anyXml.getConstraints().setMandatory(mandatory);
241 anyXml.getConstraints().addMustDefinition(must);
243 if (unknownNodes != null) {
244 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
245 anyXml.addUnknownNodeBuilder(unknown);
251 * Check if refine can be performed on given node.
256 * refine object containing information about refine process
258 public static void checkRefine(SchemaNodeBuilder node, RefineHolder refine) {
259 String name = node.getQName().getLocalName();
260 int line = refine.getLine();
262 String defaultStr = refine.getDefaultStr();
263 Boolean mandatory = refine.isMandatory();
264 Boolean presence = refine.isPresence();
265 MustDefinition must = refine.getMust();
266 Integer min = refine.getMinElements();
267 Integer max = refine.getMaxElements();
269 if (node instanceof AnyXmlBuilder) {
270 checkRefineDefault(node, defaultStr, line);
271 checkRefinePresence(node, presence, line);
272 checkRefineMinMax(name, line, min, max);
273 } else if (node instanceof ChoiceBuilder) {
274 checkRefinePresence(node, presence, line);
275 checkRefineMust(node, must, line);
276 checkRefineMinMax(name, line, min, max);
277 } else if (node instanceof ContainerSchemaNodeBuilder) {
278 checkRefineDefault(node, defaultStr, line);
279 checkRefineMandatory(node, mandatory, line);
280 checkRefineMust(node, must, line);
281 checkRefineMinMax(name, line, min, max);
282 } else if (node instanceof LeafSchemaNodeBuilder) {
283 checkRefinePresence(node, presence, line);
284 checkRefineMinMax(name, line, min, max);
285 } else if (node instanceof LeafListSchemaNodeBuilder || node instanceof ListSchemaNodeBuilder) {
286 checkRefineDefault(node, defaultStr, line);
287 checkRefinePresence(node, presence, line);
288 checkRefineMandatory(node, mandatory, line);
289 } else if (node instanceof GroupingBuilder || node instanceof TypeDefinitionBuilder
290 || node instanceof UsesNodeBuilder) {
291 checkRefineDefault(node, defaultStr, line);
292 checkRefinePresence(node, presence, line);
293 checkRefineMandatory(node, mandatory, line);
294 checkRefineMust(node, must, line);
295 checkRefineMinMax(name, line, min, max);
299 private static void checkRefineDefault(SchemaNodeBuilder node, String defaultStr, int line) {
300 if (defaultStr != null) {
301 throw new YangParseException(line, "Can not refine 'default' for '" + node.getQName().getLocalName() + "'.");
305 private static void checkRefineMandatory(SchemaNodeBuilder node, Boolean mandatory, int line) {
306 if (mandatory != null) {
307 throw new YangParseException(line, "Can not refine 'mandatory' for '" + node.getQName().getLocalName()
312 private static void checkRefinePresence(SchemaNodeBuilder node, Boolean presence, int line) {
313 if (presence != null) {
314 throw new YangParseException(line, "Can not refine 'presence' for '" + node.getQName().getLocalName()
319 private static void checkRefineMust(SchemaNodeBuilder node, MustDefinition must, int line) {
321 throw new YangParseException(line, "Can not refine 'must' for '" + node.getQName().getLocalName() + "'.");
325 private static void checkRefineMinMax(String refineTargetName, int refineLine, Integer min, Integer max) {
326 if (min != null || max != null) {
327 throw new YangParseException(refineLine, "Can not refine 'min-elements' or 'max-elements' for '"
328 + refineTargetName + "'.");
333 * Perform refine operation of following parameters:
335 * <li>description</li>
340 * These parameters may be refined for any node.
345 * refine object containing information about refine process
347 * current line in yang model
349 public static void refineDefault(final Builder node, final RefineHolder refine, final int line) {
350 Class<? extends Builder> cls = node.getClass();
352 String description = refine.getDescription();
353 if (description != null) {
355 Method method = cls.getDeclaredMethod("setDescription", String.class);
356 method.invoke(node, description);
357 } catch (Exception e) {
358 throw new YangParseException(line, "Cannot refine description in " + cls.getName(), e);
362 String reference = refine.getReference();
363 if (reference != null) {
365 Method method = cls.getDeclaredMethod("setReference", String.class);
366 method.invoke(node, reference);
367 } catch (Exception e) {
368 throw new YangParseException(line, "Cannot refine reference in " + cls.getName(), e);
372 Boolean config = refine.isConfiguration();
373 if (config != null) {
375 Method method = cls.getDeclaredMethod("setConfiguration", Boolean.class);
376 method.invoke(node, config);
377 } catch (Exception e) {
378 throw new YangParseException(line, "Cannot refine config in " + cls.getName(), e);
384 * Perform refine operation on given node.
386 * @param nodeToRefine
387 * builder of node to refine
389 * refine object containing information about refine process
391 * current line in yang model
393 public static void performRefine(SchemaNodeBuilder nodeToRefine, RefineHolder refine, int line) {
394 checkRefine(nodeToRefine, refine);
395 refineDefault(nodeToRefine, refine, line);
396 if (nodeToRefine instanceof LeafSchemaNodeBuilder) {
397 refineLeaf((LeafSchemaNodeBuilder) nodeToRefine, refine, line);
398 } else if (nodeToRefine instanceof ContainerSchemaNodeBuilder) {
399 refineContainer((ContainerSchemaNodeBuilder) nodeToRefine, refine, line);
400 } else if (nodeToRefine instanceof ListSchemaNodeBuilder) {
401 refineList((ListSchemaNodeBuilder) nodeToRefine, refine, line);
402 } else if (nodeToRefine instanceof LeafListSchemaNodeBuilder) {
403 refineLeafList((LeafListSchemaNodeBuilder) nodeToRefine, refine, line);
404 } else if (nodeToRefine instanceof ChoiceBuilder) {
405 refineChoice((ChoiceBuilder) nodeToRefine, refine, line);
406 } else if (nodeToRefine instanceof AnyXmlBuilder) {
407 refineAnyxml((AnyXmlBuilder) nodeToRefine, refine, line);