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;
12 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
13 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
14 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
15 import org.opendaylight.yangtools.yang.parser.builder.api.DocumentedNodeBuilder;
16 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
17 import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
18 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
19 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
20 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
21 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
22 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
25 * Utility class with helper methods to perform operations tied to refine
28 public final class RefineUtils {
30 private RefineUtils() {
33 private static void refineLeaf(final LeafSchemaNodeBuilder leaf, final RefineBuilder refine) {
34 String defaultStr = refine.getDefaultStr();
35 Boolean mandatory = refine.isMandatory();
36 MustDefinition must = refine.getMust();
37 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
39 if (defaultStr != null && !defaultStr.isEmpty()) {
40 leaf.setDefaultStr(defaultStr);
42 if (mandatory != null) {
43 leaf.getConstraints().setMandatory(mandatory);
46 leaf.getConstraints().addMustDefinition(must);
48 if (unknownNodes != null) {
49 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
50 unknown.setParent(leaf);
51 leaf.addUnknownNodeBuilder(unknown);
56 private static void refineContainer(final ContainerSchemaNodeBuilder container, final RefineBuilder refine) {
57 Boolean presence = refine.isPresence();
58 MustDefinition must = refine.getMust();
59 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
61 if (presence != null) {
62 container.setPresence(presence);
65 container.getConstraints().addMustDefinition(must);
67 if (unknownNodes != null) {
68 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
69 unknown.setParent(container);
70 container.addUnknownNodeBuilder(unknown);
75 private static void refineList(final ListSchemaNodeBuilder list, final RefineBuilder refine) {
76 MustDefinition must = refine.getMust();
77 Integer min = refine.getMinElements();
78 Integer max = refine.getMaxElements();
79 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
82 list.getConstraints().addMustDefinition(must);
85 list.getConstraints().setMinElements(min);
88 list.getConstraints().setMaxElements(max);
90 if (unknownNodes != null) {
91 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
92 unknown.setParent(list);
93 list.addUnknownNodeBuilder(unknown);
98 public static void refineLeafList(final LeafListSchemaNodeBuilder leafList, final RefineBuilder refine) {
99 MustDefinition must = refine.getMust();
100 Integer min = refine.getMinElements();
101 Integer max = refine.getMaxElements();
102 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
105 leafList.getConstraints().addMustDefinition(must);
108 leafList.getConstraints().setMinElements(min);
111 leafList.getConstraints().setMaxElements(max);
113 if (unknownNodes != null) {
114 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
115 unknown.setParent(leafList);
116 leafList.addUnknownNodeBuilder(unknown);
121 public static void refineChoice(final ChoiceBuilder choice, final RefineBuilder refine) {
122 String defaultStr = refine.getDefaultStr();
123 Boolean mandatory = refine.isMandatory();
124 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
126 if (defaultStr != null) {
127 choice.setDefaultCase(defaultStr);
129 if (mandatory != null) {
130 choice.getConstraints().setMandatory(mandatory);
132 if (unknownNodes != null) {
133 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
134 unknown.setParent(choice);
135 choice.addUnknownNodeBuilder(unknown);
140 public static void refineAnyxml(final AnyXmlBuilder anyXml, final RefineBuilder refine) {
141 Boolean mandatory = refine.isMandatory();
142 MustDefinition must = refine.getMust();
143 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
145 if (mandatory != null) {
146 anyXml.getConstraints().setMandatory(mandatory);
149 anyXml.getConstraints().addMustDefinition(must);
151 if (unknownNodes != null) {
152 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
153 unknown.setParent(anyXml);
154 anyXml.addUnknownNodeBuilder(unknown);
160 * Check if refine can be performed on given node.
165 * refine object containing information about refine process
167 private static void checkRefine(final SchemaNodeBuilder node, final RefineBuilder refine) {
168 String moduleName = refine.getModuleName();
169 int line = refine.getLine();
170 String name = node.getQName().getLocalName();
172 String defaultStr = refine.getDefaultStr();
173 Boolean mandatory = refine.isMandatory();
174 Boolean presence = refine.isPresence();
175 MustDefinition must = refine.getMust();
176 Integer min = refine.getMinElements();
177 Integer max = refine.getMaxElements();
179 if (node instanceof AnyXmlBuilder) {
180 checkRefineDefault(node, defaultStr, moduleName, line);
181 checkRefinePresence(node, presence, moduleName, line);
182 checkRefineMinMax(name, min, max, moduleName, line);
183 } else if (node instanceof ChoiceBuilder) {
184 checkRefinePresence(node, presence, moduleName, line);
185 checkRefineMust(node, must, moduleName, line);
186 checkRefineMinMax(name, min, max, moduleName, line);
187 } else if (node instanceof ContainerSchemaNodeBuilder) {
188 checkRefineDefault(node, defaultStr, moduleName, line);
189 checkRefineMandatory(node, mandatory, moduleName, line);
190 checkRefineMust(node, must, moduleName, line);
191 checkRefineMinMax(name, min, max, moduleName, line);
192 } else if (node instanceof LeafSchemaNodeBuilder) {
193 checkRefinePresence(node, presence, moduleName, line);
194 checkRefineMinMax(name, min, max, moduleName, line);
195 } else if (node instanceof LeafListSchemaNodeBuilder || node instanceof ListSchemaNodeBuilder) {
196 checkRefineDefault(node, defaultStr, moduleName, line);
197 checkRefinePresence(node, presence, moduleName, line);
198 checkRefineMandatory(node, mandatory, moduleName, line);
199 } else if (node instanceof GroupingBuilder || node instanceof TypeDefinitionBuilder
200 || node instanceof UsesNodeBuilder) {
201 checkRefineDefault(node, defaultStr, moduleName, line);
202 checkRefinePresence(node, presence, moduleName, line);
203 checkRefineMandatory(node, mandatory, moduleName, line);
204 checkRefineMust(node, must, moduleName, line);
205 checkRefineMinMax(name, min, max, moduleName, line);
209 private static void checkRefineDefault(final SchemaNodeBuilder node, final String defaultStr, final String moduleName, final int line) {
210 if (defaultStr != null) {
211 throw new YangParseException(moduleName, line, "Can not refine 'default' for '"
212 + node.getQName().getLocalName() + "'.");
216 private static void checkRefineMandatory(final SchemaNodeBuilder node, final Boolean mandatory, final String moduleName, final int line) {
217 if (mandatory != null) {
218 throw new YangParseException(moduleName, line, "Can not refine 'mandatory' for '"
219 + node.getQName().getLocalName() + "'.");
223 private static void checkRefinePresence(final SchemaNodeBuilder node, final Boolean presence, final String moduleName, final int line) {
224 if (presence != null) {
225 throw new YangParseException(moduleName, line, "Can not refine 'presence' for '"
226 + node.getQName().getLocalName() + "'.");
230 private static void checkRefineMust(final SchemaNodeBuilder node, final MustDefinition must, final String moduleName, final int line) {
232 throw new YangParseException(moduleName, line, "Can not refine 'must' for '"
233 + node.getQName().getLocalName() + "'.");
237 private static void checkRefineMinMax(final String refineTargetName, final Integer min, final Integer max, final String moduleName, final int line) {
238 if (min != null || max != null) {
239 throw new YangParseException(moduleName, line, "Can not refine 'min-elements' or 'max-elements' for '"
240 + refineTargetName + "'.");
245 * Perform refine operation of following parameters:
247 * <li>description</li>
252 * These parameters may be refined for any node.
257 * refine object containing information about refine process
259 private static void refineDefault(final Builder node, final RefineBuilder refine) {
260 final String moduleName = refine.getModuleName();
261 final int line = refine.getLine();
264 final DocumentedNodeBuilder documentedNode;
265 if(node instanceof DocumentedNodeBuilder) {
266 documentedNode = ((DocumentedNodeBuilder) node);
268 documentedNode = null;
271 String description = refine.getDescription();
274 if (description != null) {
275 if(documentedNode != null) {
276 documentedNode.setDescription(description);
278 throw new YangParseException(moduleName, line, String.format("Cannot refine description in of target %s",refine.getTargetPathString()));
283 String reference = refine.getReference();
284 if (reference != null) {
285 if(documentedNode != null) {
286 documentedNode.setReference(reference);
288 throw new YangParseException(moduleName, line, String.format("Cannot refine reference in of target %s",refine.getTargetPathString()));
292 Boolean config = refine.isConfiguration();
293 if (config != null) {
294 if(node instanceof DataSchemaNodeBuilder) {
295 ((DataSchemaNodeBuilder) node).setConfiguration(config);
297 throw new YangParseException(moduleName, line, String.format("Cannot refine config of target %s ",refine.getTargetPathString()));
303 * Perform refine operation on given node.
305 * @param nodeToRefine
306 * builder of node to refine
308 * refine object containing information about refine process
310 static void performRefine(final SchemaNodeBuilder nodeToRefine, final RefineBuilder refine) {
311 checkRefine(nodeToRefine, refine);
312 refineDefault(nodeToRefine, refine);
313 if (nodeToRefine instanceof LeafSchemaNodeBuilder) {
314 refineLeaf((LeafSchemaNodeBuilder) nodeToRefine, refine);
315 } else if (nodeToRefine instanceof ContainerSchemaNodeBuilder) {
316 refineContainer((ContainerSchemaNodeBuilder) nodeToRefine, refine);
317 } else if (nodeToRefine instanceof ListSchemaNodeBuilder) {
318 refineList((ListSchemaNodeBuilder) nodeToRefine, refine);
319 } else if (nodeToRefine instanceof LeafListSchemaNodeBuilder) {
320 refineLeafList((LeafListSchemaNodeBuilder) nodeToRefine, refine);
321 } else if (nodeToRefine instanceof ChoiceBuilder) {
322 refineChoice((ChoiceBuilder) nodeToRefine, refine);
323 } else if (nodeToRefine instanceof AnyXmlBuilder) {
324 refineAnyxml((AnyXmlBuilder) nodeToRefine, refine);