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.util;
10 import java.lang.reflect.Method;
11 import java.util.List;
13 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
14 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
15 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
16 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
17 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
18 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
19 import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
20 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
21 import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
22 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
23 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
24 import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
25 import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
28 * Utility class with helper methods to perform operations tied to refine
31 public class RefineUtils {
33 private RefineUtils() {
36 public static void refineLeaf(LeafSchemaNodeBuilder leaf, RefineHolder refine) {
37 String defaultStr = refine.getDefaultStr();
38 Boolean mandatory = refine.isMandatory();
39 MustDefinition must = refine.getMust();
40 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
42 if (defaultStr != null && !("".equals(defaultStr))) {
43 leaf.setDefaultStr(defaultStr);
45 if (mandatory != null) {
46 leaf.getConstraints().setMandatory(mandatory);
49 leaf.getConstraints().addMustDefinition(must);
51 if (unknownNodes != null) {
52 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
53 leaf.addUnknownNodeBuilder(unknown);
58 public static void refineContainer(ContainerSchemaNodeBuilder container, RefineHolder refine, int line) {
59 Boolean presence = refine.isPresence();
60 MustDefinition must = refine.getMust();
61 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
63 if (presence != null) {
64 container.setPresence(presence);
67 container.getConstraints().addMustDefinition(must);
69 if (unknownNodes != null) {
70 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
71 container.addUnknownNodeBuilder(unknown);
76 public static void refineList(ListSchemaNodeBuilder list, RefineHolder refine, int line) {
77 MustDefinition must = refine.getMust();
78 Integer min = refine.getMinElements();
79 Integer max = refine.getMaxElements();
80 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
83 list.getConstraints().addMustDefinition(must);
86 list.getConstraints().setMinElements(min);
89 list.getConstraints().setMaxElements(max);
91 if (unknownNodes != null) {
92 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
93 list.addUnknownNodeBuilder(unknown);
98 public static void refineLeafList(LeafListSchemaNodeBuilder leafList, RefineHolder refine, int line) {
99 MustDefinition must = refine.getMust();
100 Integer min = refine.getMinElements();
101 Integer max = refine.getMaxElements();
102 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
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 leafList.addUnknownNodeBuilder(unknown);
120 public static void refineChoice(ChoiceBuilder choice, RefineHolder refine, int line) {
121 String defaultStr = refine.getDefaultStr();
122 Boolean mandatory = refine.isMandatory();
123 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
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 choice.addUnknownNodeBuilder(unknown);
138 public static void refineAnyxml(AnyXmlBuilder anyXml, RefineHolder refine, int line) {
139 Boolean mandatory = refine.isMandatory();
140 MustDefinition must = refine.getMust();
141 List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodeBuilders();
143 if (mandatory != null) {
144 anyXml.getConstraints().setMandatory(mandatory);
147 anyXml.getConstraints().addMustDefinition(must);
149 if (unknownNodes != null) {
150 for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
151 anyXml.addUnknownNodeBuilder(unknown);
157 * Check if refine can be performed on given node.
162 * refine object containing information about refine process
164 public static void checkRefine(SchemaNodeBuilder node, RefineHolder refine) {
165 String moduleName = refine.getModuleName();
166 int line = refine.getLine();
167 String name = node.getQName().getLocalName();
169 String defaultStr = refine.getDefaultStr();
170 Boolean mandatory = refine.isMandatory();
171 Boolean presence = refine.isPresence();
172 MustDefinition must = refine.getMust();
173 Integer min = refine.getMinElements();
174 Integer max = refine.getMaxElements();
176 if (node instanceof AnyXmlBuilder) {
177 checkRefineDefault(node, defaultStr, moduleName, line);
178 checkRefinePresence(node, presence, moduleName, line);
179 checkRefineMinMax(name, min, max, moduleName, line);
180 } else if (node instanceof ChoiceBuilder) {
181 checkRefinePresence(node, presence, moduleName, line);
182 checkRefineMust(node, must, moduleName, line);
183 checkRefineMinMax(name, min, max, moduleName, line);
184 } else if (node instanceof ContainerSchemaNodeBuilder) {
185 checkRefineDefault(node, defaultStr, moduleName, line);
186 checkRefineMandatory(node, mandatory, moduleName, line);
187 checkRefineMust(node, must, moduleName, line);
188 checkRefineMinMax(name, min, max, moduleName, line);
189 } else if (node instanceof LeafSchemaNodeBuilder) {
190 checkRefinePresence(node, presence, moduleName, line);
191 checkRefineMinMax(name, min, max, moduleName, line);
192 } else if (node instanceof LeafListSchemaNodeBuilder || node instanceof ListSchemaNodeBuilder) {
193 checkRefineDefault(node, defaultStr, moduleName, line);
194 checkRefinePresence(node, presence, moduleName, line);
195 checkRefineMandatory(node, mandatory, moduleName, line);
196 } else if (node instanceof GroupingBuilder || node instanceof TypeDefinitionBuilder
197 || node instanceof UsesNodeBuilder) {
198 checkRefineDefault(node, defaultStr, moduleName, line);
199 checkRefinePresence(node, presence, moduleName, line);
200 checkRefineMandatory(node, mandatory, moduleName, line);
201 checkRefineMust(node, must, moduleName, line);
202 checkRefineMinMax(name, min, max, moduleName, line);
206 private static void checkRefineDefault(SchemaNodeBuilder node, String defaultStr, String moduleName, int line) {
207 if (defaultStr != null) {
208 throw new YangParseException(moduleName, line, "Can not refine 'default' for '"
209 + node.getQName().getLocalName() + "'.");
213 private static void checkRefineMandatory(SchemaNodeBuilder node, Boolean mandatory, String moduleName, int line) {
214 if (mandatory != null) {
215 throw new YangParseException(moduleName, line, "Can not refine 'mandatory' for '"
216 + node.getQName().getLocalName() + "'.");
220 private static void checkRefinePresence(SchemaNodeBuilder node, Boolean presence, String moduleName, int line) {
221 if (presence != null) {
222 throw new YangParseException(moduleName, line, "Can not refine 'presence' for '"
223 + node.getQName().getLocalName() + "'.");
227 private static void checkRefineMust(SchemaNodeBuilder node, MustDefinition must, String moduleName, int line) {
229 throw new YangParseException(moduleName, line, "Can not refine 'must' for '"
230 + node.getQName().getLocalName() + "'.");
234 private static void checkRefineMinMax(String refineTargetName, Integer min, Integer max, String moduleName, int line) {
235 if (min != null || max != null) {
236 throw new YangParseException(moduleName, line, "Can not refine 'min-elements' or 'max-elements' for '"
237 + refineTargetName + "'.");
242 * Perform refine operation of following parameters:
244 * <li>description</li>
249 * These parameters may be refined for any node.
254 * refine object containing information about refine process
256 public static void refineDefault(final Builder node, final RefineHolder refine) {
257 final String moduleName = refine.getModuleName();
258 final int line = refine.getLine();
259 Class<? extends Builder> cls = node.getClass();
261 String description = refine.getDescription();
262 if (description != null) {
264 Method method = cls.getDeclaredMethod("setDescription", String.class);
265 method.invoke(node, description);
266 } catch (Exception e) {
267 throw new YangParseException(moduleName, line, "Cannot refine description in " + cls.getName(), e);
271 String reference = refine.getReference();
272 if (reference != null) {
274 Method method = cls.getDeclaredMethod("setReference", String.class);
275 method.invoke(node, reference);
276 } catch (Exception e) {
277 throw new YangParseException(moduleName, line, "Cannot refine reference in " + cls.getName(), e);
281 Boolean config = refine.isConfiguration();
282 if (config != null) {
284 Method method = cls.getDeclaredMethod("setConfiguration", Boolean.class);
285 method.invoke(node, config);
286 } catch (Exception e) {
287 throw new YangParseException(moduleName, line, "Cannot refine config in " + cls.getName(), e);
293 * Perform refine operation on given node.
295 * @param nodeToRefine
296 * builder of node to refine
298 * refine object containing information about refine process
300 public static void performRefine(SchemaNodeBuilder nodeToRefine, RefineHolder refine) {
301 final int line = refine.getLine();
302 checkRefine(nodeToRefine, refine);
303 refineDefault(nodeToRefine, refine);
304 if (nodeToRefine instanceof LeafSchemaNodeBuilder) {
305 refineLeaf((LeafSchemaNodeBuilder) nodeToRefine, refine);
306 } else if (nodeToRefine instanceof ContainerSchemaNodeBuilder) {
307 refineContainer((ContainerSchemaNodeBuilder) nodeToRefine, refine, line);
308 } else if (nodeToRefine instanceof ListSchemaNodeBuilder) {
309 refineList((ListSchemaNodeBuilder) nodeToRefine, refine, line);
310 } else if (nodeToRefine instanceof LeafListSchemaNodeBuilder) {
311 refineLeafList((LeafListSchemaNodeBuilder) nodeToRefine, refine, line);
312 } else if (nodeToRefine instanceof ChoiceBuilder) {
313 refineChoice((ChoiceBuilder) nodeToRefine, refine, line);
314 } else if (nodeToRefine instanceof AnyXmlBuilder) {
315 refineAnyxml((AnyXmlBuilder) nodeToRefine, refine, line);