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;
11 import java.util.ArrayList;
12 import java.util.Date;
13 import java.util.HashSet;
14 import java.util.List;
17 import java.util.TreeMap;
19 import org.opendaylight.yangtools.yang.common.QName;
20 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
21 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
22 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
23 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
24 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
25 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
26 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
27 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
28 import org.opendaylight.yangtools.yang.model.api.Module;
29 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
30 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
31 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
32 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
33 import org.opendaylight.yangtools.yang.model.util.ExtendedType;
34 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
35 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
36 import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
37 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
38 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
39 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingMember;
40 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
41 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
42 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
43 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
44 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
45 import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
46 import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
47 import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
49 public final class GroupingUtils {
51 private GroupingUtils() {
55 * Search given modules for grouping by name defined in uses node.
58 * builder of uses statement
63 * @return grouping with given name if found, null otherwise
65 public static GroupingBuilder getTargetGroupingFromModules(final UsesNodeBuilder usesBuilder,
66 final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
67 final int line = usesBuilder.getLine();
68 final String groupingString = usesBuilder.getGroupingPathAsString();
69 String groupingPrefix;
72 if (groupingString.contains(":")) {
73 String[] splitted = groupingString.split(":");
74 if (splitted.length != 2 || groupingString.contains("/")) {
75 throw new YangParseException(module.getName(), line, "Invalid name of target grouping");
77 groupingPrefix = splitted[0];
78 groupingName = splitted[1];
80 groupingPrefix = module.getPrefix();
81 groupingName = groupingString;
84 ModuleBuilder dependentModule;
85 if (groupingPrefix.equals(module.getPrefix())) {
86 dependentModule = module;
88 dependentModule = ParserUtils.findModuleFromBuilders(modules, module, groupingPrefix, line);
91 if (dependentModule == null) {
95 GroupingBuilder result;
96 Set<GroupingBuilder> groupings = dependentModule.getGroupingBuilders();
97 result = findGroupingBuilder(groupings, groupingName);
102 Builder parent = usesBuilder.getParent();
104 while (parent != null) {
105 if (parent instanceof DataNodeContainerBuilder) {
106 groupings = ((DataNodeContainerBuilder) parent).getGroupingBuilders();
107 } else if (parent instanceof RpcDefinitionBuilder) {
108 groupings = ((RpcDefinitionBuilder) parent).getGroupings();
110 result = findGroupingBuilder(groupings, groupingName);
111 if (result == null) {
112 parent = parent.getParent();
118 if (result == null) {
119 throw new YangParseException(module.getName(), line, "Referenced grouping '" + groupingName
126 * Search context for grouping by name defined in uses node.
129 * builder of uses statement
133 * SchemaContext containing already resolved modules
134 * @return grouping with given name if found, null otherwise
136 public static GroupingDefinition getTargetGroupingFromContext(final UsesNodeBuilder usesBuilder,
137 final ModuleBuilder module, final SchemaContext context) {
138 final int line = usesBuilder.getLine();
139 String groupingString = usesBuilder.getGroupingPathAsString();
140 String groupingPrefix;
143 if (groupingString.contains(":")) {
144 String[] splitted = groupingString.split(":");
145 if (splitted.length != 2 || groupingString.contains("/")) {
146 throw new YangParseException(module.getName(), line, "Invalid name of target grouping");
148 groupingPrefix = splitted[0];
149 groupingName = splitted[1];
151 groupingPrefix = module.getPrefix();
152 groupingName = groupingString;
155 Module dependentModule = ParserUtils.findModuleFromContext(context, module, groupingPrefix, line);
156 return findGroupingDefinition(dependentModule.getGroupings(), groupingName);
160 * Find grouping by name.
163 * collection of grouping builders to search
166 * @return grouping with given name if present in collection, null otherwise
168 public static GroupingBuilder findGroupingBuilder(Set<GroupingBuilder> groupings, String name) {
169 for (GroupingBuilder grouping : groupings) {
170 if (grouping.getQName().getLocalName().equals(name)) {
178 * Find grouping by name.
181 * collection of grouping definitions to search
184 * @return grouping with given name if present in collection, null otherwise
186 public static GroupingDefinition findGroupingDefinition(Set<GroupingDefinition> groupings, String name) {
187 for (GroupingDefinition grouping : groupings) {
188 if (grouping.getQName().getLocalName().equals(name)) {
195 private static void setNodeAugmenting(DataSchemaNodeBuilder node) {
196 node.setAugmenting(true);
197 if (node instanceof DataNodeContainerBuilder) {
198 for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder)node).getChildNodeBuilders()) {
199 setNodeAugmenting(child);
202 if (node instanceof ChoiceBuilder) {
203 for (ChoiceCaseBuilder child : ((ChoiceBuilder)node).getCases()) {
204 setNodeAugmenting(child);
210 * Add nodes defined in uses target grouping to uses parent.
213 * yang uses node which will be instantiated in current location
215 public static void updateUsesParent(UsesNodeBuilder usesNode) {
216 DataNodeContainerBuilder parent = usesNode.getParent();
217 ModuleBuilder module = ParserUtils.getParentModule(parent);
218 URI ns = module.getNamespace();
219 Date rev = module.getRevision();
220 String prefix = module.getPrefix();
222 SchemaPath parentPath = parent.getPath();
223 if (parent instanceof AugmentationSchemaBuilder) {
224 parentPath = ((AugmentationSchemaBuilder) parent).getTargetNodeSchemaPath();
228 for (DataSchemaNodeBuilder child : usesNode.getTargetChildren()) {
229 setAddedByUsesToNode(child);
231 if (usesNode.isAugmenting()) {
232 //child.setAugmenting(true);
233 setNodeAugmenting(child);
235 if (usesNode.isAugmenting() && !(usesNode.getParentAugment().getParent() instanceof UsesNodeBuilder)) {
236 AugmentationSchemaBuilder parentAugment = usesNode.getParentAugment();
237 ModuleBuilder m = ParserUtils.getParentModule(parentAugment);
238 correctNodePathForUsesNodes(child, parentPath, m);
240 child.setQName(new QName(ns, rev, prefix, child.getQName().getLocalName()));
241 correctNodePathForUsesNodes(child, parentPath, module);
244 parent.addChildNode(child);
248 for (GroupingBuilder gb : usesNode.getTargetGroupings()) {
249 setAddedByUsesToNode(gb);
250 gb.setQName(new QName(ns, rev, prefix, gb.getQName().getLocalName()));
251 correctNodePathForUsesNodes(gb, parentPath, module);
252 parent.addGrouping(gb);
256 for (TypeDefinitionBuilder tdb : usesNode.getTargetTypedefs()) {
257 setAddedByUsesToNode(tdb);
258 tdb.setQName(new QName(ns, rev, prefix, tdb.getQName().getLocalName()));
259 correctNodePathForUsesNodes(tdb, parentPath, module);
260 parent.addTypedef(tdb);
264 for (UnknownSchemaNodeBuilder un : usesNode.getTargetUnknownNodes()) {
265 un.setAddedByUses(true);
266 un.setQName(new QName(ns, rev, prefix, un.getQName().getLocalName()));
267 correctNodePathForUsesNodes(un, parentPath, module);
268 parent.addUnknownNodeBuilder(un);
272 private static void setAddedByUsesToNode(GroupingMember node) {
273 node.setAddedByUses(true);
274 if (node instanceof DataNodeContainerBuilder) {
275 for (DataSchemaNodeBuilder child : ((DataNodeContainerBuilder) node).getChildNodeBuilders()) {
276 setAddedByUsesToNode(child);
279 } else if (node instanceof ChoiceBuilder) {
280 for (ChoiceCaseBuilder caseNode : ((ChoiceBuilder) node).getCases()) {
281 setAddedByUsesToNode((caseNode));
287 * Read data defined in target grouping builder, make a copy and add them to
293 public static void collectUsesData(UsesNodeBuilder usesNode) {
294 collectTargetChildNodes(usesNode);
295 collectTargetTypedefs(usesNode);
296 collectTargetGroupings(usesNode);
297 collectTargetUnknownNodes(usesNode);
298 usesNode.setDataCollected(true);
302 * Read child nodes defined in target grouping and make a copy of them.
305 * uses node for which data will be collected
307 private static void collectTargetChildNodes(UsesNodeBuilder usesNode) {
308 final GroupingBuilder target = usesNode.getGroupingBuilder();
309 final Set<DataSchemaNodeBuilder> collection = new HashSet<>();
310 addChildNodeToCollection(usesNode, collection, target.getChildNodeBuilders(), usesNode.getParent());
312 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
313 Set<DataSchemaNodeBuilder> targetUsesChildNodes = collectTargetUsesChildNodes(targetUses,
314 usesNode.getParent());
315 addChildNodeToCollection(usesNode, collection, targetUsesChildNodes, usesNode.getParent());
317 usesNode.getTargetChildren().addAll(collection);
320 private static Set<DataSchemaNodeBuilder> collectTargetUsesChildNodes(UsesNodeBuilder usesNode,
321 DataNodeContainerBuilder parent) {
322 final GroupingBuilder target = usesNode.getGroupingBuilder();
323 final Set<DataSchemaNodeBuilder> collection = new HashSet<>(usesNode.getTargetChildren());
324 addChildNodeToCollection(usesNode, collection, target.getChildNodeBuilders(), parent);
326 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
327 Set<DataSchemaNodeBuilder> targetUsesChildNodes = collectTargetUsesChildNodes(targetUses, parent);
328 addChildNodeToCollection(usesNode, collection, targetUsesChildNodes, parent);
333 private static void addChildNodeToCollection(UsesNodeBuilder usesNode, Set<DataSchemaNodeBuilder> collection,
334 Set<DataSchemaNodeBuilder> allNodes, Builder parent) {
335 for (DataSchemaNodeBuilder childNode : allNodes) {
336 boolean exists = false;
337 for (DataSchemaNodeBuilder usesChildNode : usesNode.getTargetChildren()) {
338 if (usesChildNode.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
344 DataSchemaNodeBuilder copy = CopyUtils.copy(childNode, parent, true);
345 setAddedByUsesToNode(copy);
346 collection.add(copy);
352 * Read typedefs defined in target grouping and make a copy of them.
355 * uses node for which data will be collected
357 private static void collectTargetTypedefs(UsesNodeBuilder usesNode) {
358 final GroupingBuilder target = usesNode.getGroupingBuilder();
359 Set<TypeDefinitionBuilder> collection = new HashSet<>();
360 addTypedefToCollection(usesNode, collection, target.getTypeDefinitionBuilders(), usesNode.getParent());
362 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
363 Set<TypeDefinitionBuilder> targetUsesTypedefs = collectTargetUsesTypedefs(targetUses, usesNode.getParent());
364 addTypedefToCollection(usesNode, collection, targetUsesTypedefs, usesNode.getParent());
366 usesNode.getTargetTypedefs().addAll(collection);
369 private static Set<TypeDefinitionBuilder> collectTargetUsesTypedefs(UsesNodeBuilder usesNode,
370 DataNodeContainerBuilder parent) {
371 final GroupingBuilder target = usesNode.getGroupingBuilder();
372 Set<TypeDefinitionBuilder> collection = new HashSet<>(usesNode.getTargetTypedefs());
373 addTypedefToCollection(usesNode, collection, target.getTypeDefinitionBuilders(), parent);
375 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
376 Set<TypeDefinitionBuilder> targetUsesTypedefs = collectTargetUsesTypedefs(targetUses, parent);
377 addTypedefToCollection(usesNode, collection, targetUsesTypedefs, parent);
382 private static void addTypedefToCollection(UsesNodeBuilder usesNode, Set<TypeDefinitionBuilder> collection,
383 Set<TypeDefinitionBuilder> allTypedefs, Builder parent) {
384 for (TypeDefinitionBuilder childNode : allTypedefs) {
385 boolean exists = false;
386 for (TypeDefinitionBuilder usesTypedef : usesNode.getTargetTypedefs()) {
387 if (usesTypedef.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
393 TypeDefinitionBuilder copy = CopyUtils.copy(childNode, parent, true);
394 collection.add(copy);
400 * Read groupings defined in target grouping and make a copy of them.
403 * uses node for which data will be collected
405 private static void collectTargetGroupings(UsesNodeBuilder usesNode) {
406 final GroupingBuilder target = usesNode.getGroupingBuilder();
407 Set<GroupingBuilder> collection = new HashSet<>();
408 addGroupingToCollection(usesNode, collection, target.getGroupingBuilders(), usesNode.getParent());
410 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
411 Set<GroupingBuilder> targetUsesGrouping = collectTargetGroupings(targetUses, usesNode.getParent());
412 addGroupingToCollection(usesNode, collection, targetUsesGrouping, usesNode.getParent());
414 usesNode.getTargetGroupings().addAll(collection);
417 private static Set<GroupingBuilder> collectTargetGroupings(UsesNodeBuilder usesNode, DataNodeContainerBuilder parent) {
418 final GroupingBuilder target = usesNode.getGroupingBuilder();
419 Set<GroupingBuilder> collection = new HashSet<>(usesNode.getTargetGroupings());
420 addGroupingToCollection(usesNode, collection, target.getGroupingBuilders(), parent);
422 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
423 Set<GroupingBuilder> targetUsesGroupings = collectTargetGroupings(targetUses, parent);
424 addGroupingToCollection(usesNode, collection, targetUsesGroupings, parent);
429 private static void addGroupingToCollection(UsesNodeBuilder usesNode, Set<GroupingBuilder> collection,
430 Set<GroupingBuilder> allGroupings, Builder parent) {
431 for (GroupingBuilder childNode : allGroupings) {
432 boolean exists = false;
433 for (GroupingBuilder usesGrouping : usesNode.getTargetGroupings()) {
434 if (usesGrouping.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
440 GroupingBuilder copy = CopyUtils.copy(childNode, parent, true);
441 collection.add(copy);
447 * Read unknown nodes defined in target grouping and make a copy of them.
450 * uses node for which data will be collected
452 private static void collectTargetUnknownNodes(UsesNodeBuilder usesNode) {
453 final GroupingBuilder target = usesNode.getGroupingBuilder();
454 final List<UnknownSchemaNodeBuilder> collection = new ArrayList<>();
455 addUnknownNodeToCollection(usesNode, collection, target.getUnknownNodeBuilders(), usesNode.getParent());
457 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
458 List<UnknownSchemaNodeBuilder> targetUsesUnknownNodes = collectTargetUnknownNodes(targetUses,
459 usesNode.getParent());
460 addUnknownNodeToCollection(usesNode, collection, targetUsesUnknownNodes, usesNode.getParent());
462 usesNode.getTargetUnknownNodes().addAll(collection);
465 private static List<UnknownSchemaNodeBuilder> collectTargetUnknownNodes(UsesNodeBuilder usesNode,
466 DataNodeContainerBuilder parent) {
467 final GroupingBuilder target = usesNode.getGroupingBuilder();
468 List<UnknownSchemaNodeBuilder> collection = new ArrayList<>(usesNode.getTargetUnknownNodes());
469 addUnknownNodeToCollection(usesNode, collection, target.getUnknownNodeBuilders(), parent);
471 for (UsesNodeBuilder targetUses : target.getUsesNodes()) {
472 List<UnknownSchemaNodeBuilder> targetUsesUnknownNodes = collectTargetUnknownNodes(targetUses, parent);
473 addUnknownNodeToCollection(usesNode, collection, targetUsesUnknownNodes, parent);
478 private static void addUnknownNodeToCollection(UsesNodeBuilder usesNode, List<UnknownSchemaNodeBuilder> collection,
479 List<UnknownSchemaNodeBuilder> allUnknownNodes, Builder parent) {
480 for (UnknownSchemaNodeBuilder childNode : allUnknownNodes) {
481 boolean exists = false;
482 for (UnknownSchemaNodeBuilder usesUnknownNode : usesNode.getTargetUnknownNodes()) {
483 if (usesUnknownNode.getQName().getLocalName().equals(childNode.getQName().getLocalName())) {
489 UnknownSchemaNodeBuilder copy = CopyUtils.copy(childNode, parent, true);
490 collection.add(copy);
496 * Read data defined in target grouping definition, make a copy and add them
497 * to uses node builder.
502 public static void collectUsesDataFromContext(UsesNodeBuilder usesNode) {
503 DataNodeContainerBuilder parent = usesNode.getParent();
504 URI namespace = parent.getQName().getNamespace();
505 Date revision = parent.getQName().getRevision();
506 String prefix = parent.getQName().getPrefix();
507 String moduleName = parent.getModuleName();
508 int line = parent.getLine();
511 copyGroupingNodesToUsesNode(usesNode, namespace, revision, prefix, moduleName, line);
514 final Set<GroupingBuilder> newGroupings = new HashSet<>();
515 for (GroupingDefinition g : usesNode.getGroupingDefinition().getGroupings()) {
516 QName newQName = new QName(namespace, revision, prefix, g.getQName().getLocalName());
517 GroupingBuilder newGrouping = CopyUtils.createGrouping(g, newQName, moduleName, line);
518 newGrouping.setAddedByUses(true);
519 newGroupings.add(newGrouping);
521 usesNode.getTargetGroupings().addAll(newGroupings);
524 final Set<TypeDefinitionBuilder> newTypedefs = new HashSet<>();
525 for (TypeDefinition<?> td : usesNode.getGroupingDefinition().getTypeDefinitions()) {
526 QName newQName = new QName(namespace, revision, prefix, td.getQName().getLocalName());
527 TypeDefinitionBuilder newType = CopyUtils.createTypedef((ExtendedType) td, newQName, moduleName, line);
528 newType.setAddedByUses(true);
529 newTypedefs.add(newType);
531 usesNode.getTargetTypedefs().addAll(newTypedefs);
534 final List<UnknownSchemaNodeBuilder> newUnknownNodes = new ArrayList<>();
535 for (UnknownSchemaNode un : usesNode.getGroupingDefinition().getUnknownSchemaNodes()) {
536 QName newQName = new QName(namespace, revision, prefix, un.getQName().getLocalName());
537 UnknownSchemaNodeBuilder newNode = CopyUtils.createUnknownSchemaNode(un, newQName, moduleName, line);
538 newNode.setAddedByUses(true);
539 newUnknownNodes.add(newNode);
541 usesNode.getTargetUnknownNodes().addAll(newUnknownNodes);
543 usesNode.setDataCollected(true);
547 * Read data defined in target grouping definition, make a copy and add them
548 * to uses node builder.
551 * used node builder to which are copied nodes from its
552 * <code>GroupingDefinition</code>
554 * URI with parent namespace
556 * date with parent revision date
558 * string with parent prefix
560 * string with parent module name
562 * number with YANG file row where is the parent defined
564 private static void copyGroupingNodesToUsesNode(final UsesNodeBuilder usesNode, final URI namespace,
565 final Date revision, final String prefix, final String moduleName, final int lineNumber) {
566 final Set<DataSchemaNodeBuilder> newChildren = new HashSet<>();
567 for (DataSchemaNode child : usesNode.getGroupingDefinition().getChildNodes()) {
569 DataSchemaNodeBuilder newChild = null;
570 QName newQName = new QName(namespace, revision, prefix, child.getQName().getLocalName());
571 if (child instanceof AnyXmlSchemaNode) {
572 newChild = CopyUtils.createAnyXml((AnyXmlSchemaNode) child, newQName, moduleName, lineNumber);
573 } else if (child instanceof ChoiceNode) {
574 newChild = CopyUtils.createChoice((ChoiceNode) child, newQName, moduleName, lineNumber);
575 } else if (child instanceof ContainerSchemaNode) {
576 newChild = CopyUtils.createContainer((ContainerSchemaNode) child, newQName, moduleName, lineNumber);
577 } else if (child instanceof LeafListSchemaNode) {
578 newChild = CopyUtils.createLeafList((LeafListSchemaNode) child, newQName, moduleName, lineNumber);
579 } else if (child instanceof LeafSchemaNode) {
580 newChild = CopyUtils.createLeafBuilder((LeafSchemaNode) child, newQName, moduleName, lineNumber);
581 } else if (child instanceof ListSchemaNode) {
582 newChild = CopyUtils.createList((ListSchemaNode) child, newQName, moduleName, lineNumber);
585 if (newChild == null) {
586 throw new YangParseException(moduleName, lineNumber,
587 "Unknown member of target grouping while resolving uses node.");
590 ((GroupingMember) newChild).setAddedByUses(true);
591 newChildren.add(newChild);
594 usesNode.getTargetChildren().addAll(newChildren);
599 * Correct schema path of nodes added by uses statement.
602 * node added by uses statement
603 * @param parentSchemaPath
604 * schema path of parent node
605 * @param parentModule
606 * current parent node module
608 private static void correctNodePathForUsesNodes(final SchemaNodeBuilder node, final SchemaPath parentSchemaPath,
609 final ModuleBuilder parentModule) {
611 List<QName> targetNodePath = new ArrayList<>(parentSchemaPath.getPath());
612 targetNodePath.add(new QName(parentModule.getNamespace(), parentModule.getRevision(), parentModule.getPrefix(),
613 node.getQName().getLocalName()));
614 node.setPath(new SchemaPath(targetNodePath, true));
616 // set correct path for all child nodes
617 if (node instanceof DataNodeContainerBuilder) {
618 DataNodeContainerBuilder dataNodeContainer = (DataNodeContainerBuilder) node;
619 for (DataSchemaNodeBuilder child : dataNodeContainer.getChildNodeBuilders()) {
620 correctNodePathForUsesNodes(child, node.getPath(), parentModule);
624 // set correct path for all cases
625 if (node instanceof ChoiceBuilder) {
626 ChoiceBuilder choiceBuilder = (ChoiceBuilder) node;
627 for (ChoiceCaseBuilder choiceCaseBuilder : choiceBuilder.getCases()) {
628 correctNodePathForUsesNodes(choiceCaseBuilder, node.getPath(), parentModule);
634 * Perform refinement of uses target grouping nodes. Uses process has to be
638 * uses node containing refine statements
640 public static void performRefine(UsesNodeBuilder usesNode) {
641 for (RefineHolder refine : usesNode.getRefines()) {
642 String refineTargetPath = refine.getName();
644 String[] splitted = refineTargetPath.split("/");
645 Builder currentNode = usesNode.getParent();
646 for (String pathElement : splitted) {
647 if (currentNode instanceof DataNodeContainerBuilder) {
648 currentNode = ((DataNodeContainerBuilder) currentNode).getDataChildByName(pathElement);
649 } else if (currentNode instanceof ChoiceBuilder) {
650 currentNode = ((ChoiceBuilder) currentNode).getCaseNodeByName(pathElement);
654 DataSchemaNodeBuilder nodeToRefine = (DataSchemaNodeBuilder) currentNode;
655 if (nodeToRefine == null) {
656 throw new YangParseException(refine.getModuleName(), refine.getLine(), "Refine target node '"
657 + refine.getName() + "' not found");
659 RefineUtils.performRefine(nodeToRefine, refine);
660 usesNode.addRefineNode(nodeToRefine);