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.yangtools.yang.parser.builder.impl;
10 import java.util.List;
11 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
12 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
13 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
14 import org.opendaylight.yangtools.yang.parser.builder.api.DocumentedNodeBuilder;
15 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
16 import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
17 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
18 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
19 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
20 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
21 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
24 * Utility class with helper methods to perform operations tied to refine
27 public final class RefineUtils {
29 private RefineUtils() {
32 private static void refineLeaf(final LeafSchemaNodeBuilder leaf, final RefineBuilder refine) {
33 String defaultStr = refine.getDefaultStr();
34 Boolean mandatory = refine.isMandatory();
35 MustDefinition must = refine.getMust();
36 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
38 if (defaultStr != null && !("".equals(defaultStr))) {
39 leaf.setDefaultStr(defaultStr);
41 if (mandatory != null) {
42 leaf.getConstraints().setMandatory(mandatory);
45 leaf.getConstraints().addMustDefinition(must);
47 if (unknownNodes != null) {
48 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
49 unknown.setParent(leaf);
50 leaf.addUnknownNodeBuilder(unknown);
55 private static void refineContainer(final ContainerSchemaNodeBuilder container, final RefineBuilder refine) {
56 Boolean presence = refine.isPresence();
57 MustDefinition must = refine.getMust();
58 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
60 if (presence != null) {
61 container.setPresence(presence);
64 container.getConstraints().addMustDefinition(must);
66 if (unknownNodes != null) {
67 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
68 unknown.setParent(container);
69 container.addUnknownNodeBuilder(unknown);
74 private static void refineList(final ListSchemaNodeBuilder list, final RefineBuilder refine) {
75 MustDefinition must = refine.getMust();
76 Integer min = refine.getMinElements();
77 Integer max = refine.getMaxElements();
78 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
81 list.getConstraints().addMustDefinition(must);
84 list.getConstraints().setMinElements(min);
87 list.getConstraints().setMaxElements(max);
89 if (unknownNodes != null) {
90 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
91 unknown.setParent(list);
92 list.addUnknownNodeBuilder(unknown);
97 public static void refineLeafList(final LeafListSchemaNodeBuilder leafList, final RefineBuilder refine) {
98 MustDefinition must = refine.getMust();
99 Integer min = refine.getMinElements();
100 Integer max = refine.getMaxElements();
101 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
104 leafList.getConstraints().addMustDefinition(must);
107 leafList.getConstraints().setMinElements(min);
110 leafList.getConstraints().setMaxElements(max);
112 if (unknownNodes != null) {
113 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
114 unknown.setParent(leafList);
115 leafList.addUnknownNodeBuilder(unknown);
120 public static void refineChoice(final ChoiceBuilder choice, final RefineBuilder refine) {
121 String defaultStr = refine.getDefaultStr();
122 Boolean mandatory = refine.isMandatory();
123 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
125 if (defaultStr != null) {
126 choice.setDefaultCase(defaultStr);
128 if (mandatory != null) {
129 choice.getConstraints().setMandatory(mandatory);
131 if (unknownNodes != null) {
132 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
133 unknown.setParent(choice);
134 choice.addUnknownNodeBuilder(unknown);
139 public static void refineAnyxml(final AnyXmlBuilder anyXml, final RefineBuilder refine) {
140 Boolean mandatory = refine.isMandatory();
141 MustDefinition must = refine.getMust();
142 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
144 if (mandatory != null) {
145 anyXml.getConstraints().setMandatory(mandatory);
148 anyXml.getConstraints().addMustDefinition(must);
150 if (unknownNodes != null) {
151 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
152 unknown.setParent(anyXml);
153 anyXml.addUnknownNodeBuilder(unknown);
159 * Check if refine can be performed on given node.
164 * refine object containing information about refine process
166 private static void checkRefine(final SchemaNodeBuilder node, final RefineBuilder refine) {
167 String moduleName = refine.getModuleName();
168 int line = refine.getLine();
169 String name = node.getQName().getLocalName();
171 String defaultStr = refine.getDefaultStr();
172 Boolean mandatory = refine.isMandatory();
173 Boolean presence = refine.isPresence();
174 MustDefinition must = refine.getMust();
175 Integer min = refine.getMinElements();
176 Integer max = refine.getMaxElements();
178 if (node instanceof AnyXmlBuilder) {
179 checkRefineDefault(node, defaultStr, moduleName, line);
180 checkRefinePresence(node, presence, moduleName, line);
181 checkRefineMinMax(name, min, max, moduleName, line);
182 } else if (node instanceof ChoiceBuilder) {
183 checkRefinePresence(node, presence, moduleName, line);
184 checkRefineMust(node, must, moduleName, line);
185 checkRefineMinMax(name, min, max, moduleName, line);
186 } else if (node instanceof ContainerSchemaNodeBuilder) {
187 checkRefineDefault(node, defaultStr, moduleName, line);
188 checkRefineMandatory(node, mandatory, moduleName, line);
189 checkRefineMust(node, must, moduleName, line);
190 checkRefineMinMax(name, min, max, moduleName, line);
191 } else if (node instanceof LeafSchemaNodeBuilder) {
192 checkRefinePresence(node, presence, moduleName, line);
193 checkRefineMinMax(name, min, max, moduleName, line);
194 } else if (node instanceof LeafListSchemaNodeBuilder || node instanceof ListSchemaNodeBuilder) {
195 checkRefineDefault(node, defaultStr, moduleName, line);
196 checkRefinePresence(node, presence, moduleName, line);
197 checkRefineMandatory(node, mandatory, moduleName, line);
198 } else if (node instanceof GroupingBuilder || node instanceof TypeDefinitionBuilder
199 || node instanceof UsesNodeBuilder) {
200 checkRefineDefault(node, defaultStr, moduleName, line);
201 checkRefinePresence(node, presence, moduleName, line);
202 checkRefineMandatory(node, mandatory, moduleName, line);
203 checkRefineMust(node, must, moduleName, line);
204 checkRefineMinMax(name, min, max, moduleName, line);
208 private static void checkRefineDefault(final SchemaNodeBuilder node, final String defaultStr, final String moduleName, final int line) {
209 if (defaultStr != null) {
210 throw new YangParseException(moduleName, line, "Can not refine 'default' for '"
211 + node.getQName().getLocalName() + "'.");
215 private static void checkRefineMandatory(final SchemaNodeBuilder node, final Boolean mandatory, final String moduleName, final int line) {
216 if (mandatory != null) {
217 throw new YangParseException(moduleName, line, "Can not refine 'mandatory' for '"
218 + node.getQName().getLocalName() + "'.");
222 private static void checkRefinePresence(final SchemaNodeBuilder node, final Boolean presence, final String moduleName, final int line) {
223 if (presence != null) {
224 throw new YangParseException(moduleName, line, "Can not refine 'presence' for '"
225 + node.getQName().getLocalName() + "'.");
229 private static void checkRefineMust(final SchemaNodeBuilder node, final MustDefinition must, final String moduleName, final int line) {
231 throw new YangParseException(moduleName, line, "Can not refine 'must' for '"
232 + node.getQName().getLocalName() + "'.");
236 private static void checkRefineMinMax(final String refineTargetName, final Integer min, final Integer max, final String moduleName, final int line) {
237 if (min != null || max != null) {
238 throw new YangParseException(moduleName, line, "Can not refine 'min-elements' or 'max-elements' for '"
239 + refineTargetName + "'.");
244 * Perform refine operation of following parameters:
246 * <li>description</li>
251 * These parameters may be refined for any node.
256 * refine object containing information about refine process
258 private static void refineDefault(final Builder node, final RefineBuilder refine) {
259 final String moduleName = refine.getModuleName();
260 final int line = refine.getLine();
263 final DocumentedNodeBuilder documentedNode;
264 if(node instanceof DocumentedNodeBuilder) {
265 documentedNode = ((DocumentedNodeBuilder) node);
267 documentedNode = null;
270 String description = refine.getDescription();
273 if (description != null) {
274 if(documentedNode != null) {
275 documentedNode.setDescription(description);
277 throw new YangParseException(moduleName, line, String.format("Cannot refine description in of target %s",refine.getTargetPathString()));
282 String reference = refine.getReference();
283 if (reference != null) {
284 if(documentedNode != null) {
285 documentedNode.setReference(reference);
287 throw new YangParseException(moduleName, line, String.format("Cannot refine reference in of target %s",refine.getTargetPathString()));
291 Boolean config = refine.isConfiguration();
292 if (config != null) {
293 if(node instanceof DataSchemaNodeBuilder) {
294 ((DataSchemaNodeBuilder) node).setConfiguration(config);
296 throw new YangParseException(moduleName, line, String.format("Cannot refine config of target %s ",refine.getTargetPathString()));
302 * Perform refine operation on given node.
304 * @param nodeToRefine
305 * builder of node to refine
307 * refine object containing information about refine process
309 static void performRefine(final SchemaNodeBuilder nodeToRefine, final RefineBuilder refine) {
310 checkRefine(nodeToRefine, refine);
311 refineDefault(nodeToRefine, refine);
312 if (nodeToRefine instanceof LeafSchemaNodeBuilder) {
313 refineLeaf((LeafSchemaNodeBuilder) nodeToRefine, refine);
314 } else if (nodeToRefine instanceof ContainerSchemaNodeBuilder) {
315 refineContainer((ContainerSchemaNodeBuilder) nodeToRefine, refine);
316 } else if (nodeToRefine instanceof ListSchemaNodeBuilder) {
317 refineList((ListSchemaNodeBuilder) nodeToRefine, refine);
318 } else if (nodeToRefine instanceof LeafListSchemaNodeBuilder) {
319 refineLeafList((LeafListSchemaNodeBuilder) nodeToRefine, refine);
320 } else if (nodeToRefine instanceof ChoiceBuilder) {
321 refineChoice((ChoiceBuilder) nodeToRefine, refine);
322 } else if (nodeToRefine instanceof AnyXmlBuilder) {
323 refineAnyxml((AnyXmlBuilder) nodeToRefine, refine);