Refactored base yang-java types.
[yangtools.git] / yang / yang-parser-impl / src / main / java / org / opendaylight / yangtools / yang / parser / util / CopyUtils.java
1 /*
2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
3  *
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
7  */
8 package org.opendaylight.yangtools.yang.parser.util;
9
10 import java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.List;
13 import java.util.Set;
14
15 import org.opendaylight.yangtools.yang.common.QName;
16 import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
17 import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
18 import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
19 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
20 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
21 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
22 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
23 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
24 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
25 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
26 import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
27 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
28 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
29 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
30 import org.opendaylight.yangtools.yang.model.util.ExtendedType;
31 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
32 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
33 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
34 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
35 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
36 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
37 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
38 import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
39 import org.opendaylight.yangtools.yang.parser.builder.impl.AugmentationSchemaBuilderImpl;
40 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
41 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
42 import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
43 import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
44 import org.opendaylight.yangtools.yang.parser.builder.impl.GroupingBuilderImpl;
45 import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
46 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
47 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
48 import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
49 import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
50 import org.opendaylight.yangtools.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
51 import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
52 import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
53 import org.opendaylight.yangtools.yang.parser.builder.impl.UsesNodeBuilderImpl;
54
55 public class CopyUtils {
56
57     /**
58      * Create copy of DataSchemaNodeBuilder with new parent. If updateQName is
59      * true, qname of node will be corrected based on new parent.
60      *
61      * @param old
62      * @param newParent
63      * @param updateQName
64      * @return
65      */
66     public static DataSchemaNodeBuilder copy(DataSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
67         if (old instanceof AnyXmlBuilder) {
68             return copy((AnyXmlBuilder) old, newParent, updateQName);
69         } else if (old instanceof ChoiceBuilder) {
70             return copy((ChoiceBuilder) old, newParent, updateQName);
71         } else if (old instanceof ContainerSchemaNodeBuilder) {
72             return copy((ContainerSchemaNodeBuilder) old, newParent, updateQName);
73         } else if (old instanceof LeafSchemaNodeBuilder) {
74             return copy((LeafSchemaNodeBuilder) old, newParent, updateQName);
75         } else if (old instanceof LeafListSchemaNodeBuilder) {
76             return copy((LeafListSchemaNodeBuilder) old, newParent, updateQName);
77         } else if (old instanceof ListSchemaNodeBuilder) {
78             return copy((ListSchemaNodeBuilder) old, newParent, updateQName);
79         } else if (old instanceof ChoiceCaseBuilder) {
80             return copy((ChoiceCaseBuilder) old, newParent, updateQName);
81         } else {
82             throw new YangParseException(old.getModuleName(), old.getLine(),
83                     "Failed to copy node: Unknown type of DataSchemaNode: " + old);
84         }
85     }
86
87     private static AnyXmlBuilder copy(AnyXmlBuilder old, Builder newParent, boolean updateQName) {
88         DataBean data = getdata(old, newParent, updateQName);
89         QName newQName = data.qname;
90         SchemaPath newSchemaPath = data.schemaPath;
91
92         AnyXmlBuilder copy = new AnyXmlBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
93         copyConstraints(copy.getConstraints(), old.getConstraints());
94         copy.setParent(newParent);
95         copy.setPath(newSchemaPath);
96         copy.setDescription(old.getDescription());
97         copy.setReference(old.getReference());
98         copy.setStatus(old.getStatus());
99         copy.setAugmenting(old.isAugmenting());
100         copy.setAddedByUses(old.isAddedByUses());
101         copy.setConfiguration(old.isConfiguration());
102         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
103             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
104         }
105
106         return copy;
107     }
108
109     private static ChoiceBuilder copy(ChoiceBuilder old, Builder newParent, boolean updateQName) {
110         DataBean data = getdata(old, newParent, updateQName);
111         QName newQName = data.qname;
112         SchemaPath newSchemaPath = data.schemaPath;
113
114         ChoiceBuilder copy = new ChoiceBuilder(newParent.getModuleName(), newParent.getLine(), newQName);
115         copyConstraints(copy.getConstraints(), old.getConstraints());
116         copy.setParent(newParent);
117         copy.setPath(newSchemaPath);
118         copy.setDescription(old.getDescription());
119         copy.setReference(old.getReference());
120         copy.setStatus(old.getStatus());
121         copy.setAugmenting(old.isAugmenting());
122         copy.setAddedByUses(old.isAddedByUses());
123         copy.setConfiguration(old.isConfiguration());
124         for (ChoiceCaseBuilder childNode : old.getCases()) {
125             copy.addCase(copy(childNode, copy, updateQName));
126         }
127         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
128             copy.addAugmentation(copyAugment(augment, copy));
129         }
130         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
131             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
132         }
133
134         return copy;
135     }
136
137     private static ChoiceCaseBuilder copy(ChoiceCaseBuilder old, Builder newParent, boolean updateQName) {
138         DataBean data = getdata(old, newParent, updateQName);
139         QName newQName = data.qname;
140         SchemaPath newSchemaPath = data.schemaPath;
141
142         ChoiceCaseBuilder copy = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName);
143         copyConstraints(copy.getConstraints(), old.getConstraints());
144         copy.setParent(newParent);
145         copy.setPath(newSchemaPath);
146         copy.setDescription(old.getDescription());
147         copy.setReference(old.getReference());
148         copy.setStatus(old.getStatus());
149         copy.setAugmenting(old.isAugmenting());
150         copy.getChildNodes().addAll(old.getChildNodes());
151         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
152             copy.addChildNode(copy(childNode, copy, updateQName));
153         }
154         copy.getGroupings().addAll(old.getGroupings());
155         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
156             copy.addGrouping(copy(grouping, copy, updateQName));
157         }
158         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
159             copy.addTypedef(copy(tdb, copy, updateQName));
160         }
161         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
162             copy.addUsesNode(copyUses(oldUses, copy));
163         }
164         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
165             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
166         }
167
168         return copy;
169     }
170
171     private static ContainerSchemaNodeBuilder copy(ContainerSchemaNodeBuilder old, Builder newParent,
172             boolean updateQName) {
173         DataBean data = getdata(old, newParent, updateQName);
174         QName newQName = data.qname;
175         SchemaPath newSchemaPath = data.schemaPath;
176
177         ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
178                 newQName, newSchemaPath);
179         copyConstraints(copy.getConstraints(), old.getConstraints());
180         copy.setParent(newParent);
181         copy.setPath(newSchemaPath);
182         copy.setDescription(old.getDescription());
183         copy.setReference(old.getReference());
184         copy.setStatus(old.getStatus());
185         copy.setPresence(old.isPresence());
186         copy.setAugmenting(old.isAugmenting());
187         copy.setAddedByUses(old.isAddedByUses());
188         copy.setConfiguration(old.isConfiguration());
189         copy.setChildNodes(old.getChildNodes());
190         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
191             copy.addChildNode(copy(childNode, copy, updateQName));
192         }
193         copy.getGroupings().addAll(old.getGroupings());
194         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
195             copy.addGrouping(copy(grouping, copy, updateQName));
196         }
197         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
198             copy.addTypedef(copy(tdb, copy, updateQName));
199         }
200         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
201             copy.addUsesNode(copyUses(oldUses, copy));
202         }
203         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
204             copy.addAugmentation(copyAugment(augment, copy));
205         }
206         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
207             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
208         }
209
210         return copy;
211     }
212
213     private static LeafSchemaNodeBuilder copy(LeafSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
214         DataBean data = getdata(old, newParent, updateQName);
215         QName newQName = data.qname;
216         SchemaPath newSchemaPath = data.schemaPath;
217
218         LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(), newQName,
219                 newSchemaPath);
220         copyConstraints(copy.getConstraints(), old.getConstraints());
221         copy.setParent(newParent);
222         copy.setPath(newSchemaPath);
223         copy.setDescription(old.getDescription());
224         copy.setReference(old.getReference());
225         copy.setStatus(old.getStatus());
226         copy.setAugmenting(old.isAugmenting());
227         copy.setAddedByUses(old.isAddedByUses());
228         copy.setConfiguration(old.isConfiguration());
229         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
230             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
231         }
232
233         if (old.getType() == null) {
234             copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
235         } else {
236             copy.setType(old.getType());
237         }
238
239         copy.setDefaultStr(old.getDefaultStr());
240         copy.setUnits(old.getUnits());
241
242         return copy;
243     }
244
245     public static LeafListSchemaNodeBuilder copy(LeafListSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
246         DataBean data = getdata(old, newParent, updateQName);
247         QName newQName = data.qname;
248         SchemaPath newSchemaPath = data.schemaPath;
249
250         LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
251                 newQName, newSchemaPath);
252         copyConstraints(copy.getConstraints(), old.getConstraints());
253         copy.setParent(newParent);
254         copy.setPath(newSchemaPath);
255         copy.setDescription(old.getDescription());
256         copy.setReference(old.getReference());
257         copy.setStatus(old.getStatus());
258         copy.setAugmenting(old.isAugmenting());
259         copy.setAddedByUses(old.isAddedByUses());
260         copy.setConfiguration(old.isConfiguration());
261         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
262             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
263         }
264
265         if (old.getType() == null) {
266             copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
267         } else {
268             copy.setType(old.getType());
269         }
270
271         copy.setUserOrdered(old.isUserOrdered());
272
273         return copy;
274     }
275
276     private static ListSchemaNodeBuilder copy(ListSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
277         DataBean data = getdata(old, newParent, updateQName);
278         QName newQName = data.qname;
279         SchemaPath newSchemaPath = data.schemaPath;
280
281         ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(), newQName,
282                 newSchemaPath);
283         copyConstraints(copy.getConstraints(), old.getConstraints());
284         copy.setParent(newParent);
285         copy.setPath(newSchemaPath);
286         copy.setDescription(old.getDescription());
287         copy.setReference(old.getReference());
288         copy.setStatus(old.getStatus());
289         copy.setAugmenting(old.isAugmenting());
290         copy.setAddedByUses(old.isAddedByUses());
291         copy.setConfiguration(old.isConfiguration());
292         copy.setChildNodes(old.getChildNodes());
293         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
294             copy.addChildNode(copy(childNode, copy, updateQName));
295         }
296         copy.getGroupings().addAll(old.getGroupings());
297         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
298             copy.addGrouping(copy(grouping, copy, updateQName));
299         }
300         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
301             copy.addTypedef(copy(tdb, copy, updateQName));
302         }
303         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
304             copy.addUsesNode(copyUses(oldUses, copy));
305         }
306         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
307             copy.addAugmentation(copyAugment(augment, copy));
308         }
309         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
310             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
311         }
312
313         copy.setUserOrdered(old.isUserOrdered());
314         copy.setKeyDefinition(old.getKeyDefinition());
315
316         return copy;
317     }
318
319     public static GroupingBuilder copy(GroupingBuilder old, Builder newParent, boolean updateQName) {
320         DataBean data = getdata(old, newParent, updateQName);
321         QName newQName = data.qname;
322         SchemaPath newSchemaPath = data.schemaPath;
323
324         GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName);
325         copy.setParent(newParent);
326         copy.setPath(newSchemaPath);
327         copy.setDescription(old.getDescription());
328         copy.setReference(old.getReference());
329         copy.setStatus(old.getStatus());
330         copy.setAddedByUses(old.isAddedByUses());
331         copy.setChildNodes(old.getChildNodes());
332         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
333             copy.addChildNode(copy(childNode, copy, updateQName));
334         }
335         copy.getGroupings().addAll(old.getGroupings());
336         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
337             copy.addGrouping(copy(grouping, copy, updateQName));
338         }
339         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
340             copy.addTypedef(copy(tdb, copy, updateQName));
341         }
342         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
343             copy.addUsesNode(copyUses(oldUses, copy));
344         }
345         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
346             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
347         }
348
349         return copy;
350     }
351
352     public static TypeDefinitionBuilder copy(TypeDefinitionBuilder old, Builder newParent, boolean updateQName) {
353         DataBean data = getdata(old, newParent, updateQName);
354         QName newQName = data.qname;
355         SchemaPath newSchemaPath = data.schemaPath;
356         TypeDefinitionBuilder type = null;
357
358         if (old instanceof UnionTypeBuilder) {
359             UnionTypeBuilder oldUnion = (UnionTypeBuilder)old;
360             type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
361             type.setParent(newParent);
362             for(TypeDefinition<?> td : oldUnion.getTypes()) {
363                 type.setType(td);
364             }
365             for(TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
366                 type.setTypedef(copy(tdb, type, updateQName));
367             }
368         } else if (old instanceof IdentityrefTypeBuilder) {
369             type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
370                     ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
371             type.setParent(newParent);
372             type.setPath(newSchemaPath);
373         } else {
374             type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName);
375             type.setParent(newParent);
376             type.setPath(newSchemaPath);
377
378             if (old.getType() == null) {
379                 type.setTypedef(copy(old.getTypedef(), type, updateQName));
380             } else {
381                 type.setType(old.getType());
382             }
383
384             for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
385                 type.addUnknownNodeBuilder((copy(un, type, updateQName)));
386             }
387
388             type.setRanges(old.getRanges());
389             type.setLengths(old.getLengths());
390             type.setPatterns(old.getPatterns());
391             type.setFractionDigits(old.getFractionDigits());
392             type.setDescription(old.getDescription());
393             type.setReference(old.getReference());
394             type.setStatus(old.getStatus());
395             type.setUnits(old.getUnits());
396             type.setDefaultValue(old.getDefaultValue());
397             type.setAddedByUses(old.isAddedByUses());
398         }
399
400         return type;
401     }
402
403     private static ConstraintsBuilder copyConstraints(ConstraintsBuilder newConstraints, ConstraintsBuilder old) {
404         newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
405         newConstraints.addWhenCondition(old.getWhenCondition());
406         newConstraints.setMandatory(old.isMandatory());
407         newConstraints.setMinElements(old.getMinElements());
408         newConstraints.setMaxElements(old.getMaxElements());
409         return newConstraints;
410     }
411
412     static UsesNodeBuilder copyUses(UsesNodeBuilder old, Builder newParent) {
413         UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
414                 old.getGroupingName(), true);
415         copy.setParent(newParent);
416         copy.setGroupingPath(old.getGroupingPath());
417         // TODO grouping vs grouping path?
418         copy.setGrouping(old.getGroupingBuilder());
419         copy.setAugmenting(old.isAugmenting());
420         copy.setAddedByUses(old.isAddedByUses());
421         copy.getAugmentations().addAll(old.getAugmentations());
422         copy.getRefineNodes().addAll(old.getRefineNodes());
423         copy.getRefines().addAll(old.getRefines());
424
425         copy.setTargetChildren(old.getTargetChildren());
426         copy.setTargetTypedefs(old.getTargetTypedefs());
427         copy.setTargetGroupings(old.getTargetGroupings());
428         copy.setTargetUnknownNodes(old.getTargetUnknownNodes());
429
430         // add new uses to collection of uses in module
431         ModuleBuilder module = ParserUtils.getParentModule(newParent);
432         module.getAllUsesNodes().add(copy);
433
434         return copy;
435     }
436
437     private static AugmentationSchemaBuilder copyAugment(AugmentationSchemaBuilder old, Builder newParent) {
438         AugmentationSchemaBuilderImpl copy = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
439                 newParent.getLine(), old.getTargetPathAsString());
440         copy.setParent(newParent);
441
442         copy.setDescription(old.getDescription());
443         copy.setReference(old.getReference());
444         copy.setStatus(old.getStatus());
445         copy.addWhenCondition(old.getWhenCondition());
446         copy.setChildNodes(old.getChildNodes());
447         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
448             copy.addChildNode(copy(childNode, copy, false));
449         }
450         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
451             copy.addUsesNode(copyUses(oldUses, copy));
452         }
453         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
454             copy.addUnknownNodeBuilder((copy(un, copy, false)));
455         }
456
457         return copy;
458     }
459
460     static UnknownSchemaNodeBuilder copy(UnknownSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
461         DataBean data = getdata(old, newParent, updateQName);
462         QName newQName = data.qname;
463         SchemaPath newSchemaPath = data.schemaPath;
464
465         UnknownSchemaNodeBuilder c = new UnknownSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
466                 newQName);
467
468         c.setParent(newParent);
469         c.setPath(newSchemaPath);
470         c.setDescription(old.getDescription());
471         c.setReference(old.getReference());
472         c.setStatus(old.getStatus());
473         c.setAddedByUses(old.isAddedByUses());
474         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
475             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
476         }
477
478         return c;
479     }
480
481     private static DataBean getdata(SchemaNodeBuilder old, Builder newParent, boolean updateQName) {
482         List<QName> newPath = null;
483         QName newQName = null;
484         if (newParent instanceof ModuleBuilder) {
485             ModuleBuilder parent = (ModuleBuilder) newParent;
486             if (updateQName) {
487                 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
488                         .getLocalName());
489                 newPath = Collections.singletonList(newQName);
490             } else {
491                 newQName = old.getQName();
492                 newPath = Collections.singletonList(newQName);
493             }
494         } else if (newParent instanceof AugmentationSchemaBuilder) {
495             ModuleBuilder parent = ParserUtils.getParentModule(newParent);
496             if (updateQName) {
497                 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
498                         .getLocalName());
499                 newPath = Collections.singletonList(newQName);
500             } else {
501                 newQName = old.getQName();
502                 newPath = Collections.singletonList(newQName);
503             }
504
505         } else if (newParent instanceof SchemaNodeBuilder) {
506             SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
507             QName parentQName = parent.getQName();
508             if (updateQName) {
509                 newQName = new QName(parentQName.getNamespace(), parentQName.getRevision(), parentQName.getPrefix(),
510                         old.getQName().getLocalName());
511                 newPath = new ArrayList<>(parent.getPath().getPath());
512                 newPath.add(newQName);
513             } else {
514                 newQName = old.getQName();
515                 newPath = new ArrayList<>(parent.getPath().getPath());
516                 newPath.add(newQName);
517             }
518         }
519
520         SchemaPath newSchemaPath = new SchemaPath(newPath, true);
521         return new DataBean(newQName, newSchemaPath);
522     }
523
524     private static class DataBean {
525         private QName qname;
526         private SchemaPath schemaPath;
527
528         private DataBean(QName qname, SchemaPath schemaPath) {
529             this.qname = qname;
530             this.schemaPath = schemaPath;
531         }
532     }
533
534
535     /**
536      * Create AnyXmlBuilder from given AnyXmlSchemaNode.
537      *
538      * @param anyxml
539      * @param qname
540      * @param moduleName
541      *            current module name
542      * @param line
543      *            current line in module
544      * @return anyxml builder based on given anyxml node
545      */
546     public static AnyXmlBuilder createAnyXml(AnyXmlSchemaNode anyxml, QName qname, String moduleName, int line) {
547         final AnyXmlBuilder builder = new AnyXmlBuilder(moduleName, line, qname, anyxml.getPath());
548         convertDataSchemaNode(anyxml, builder);
549         builder.setConfiguration(anyxml.isConfiguration());
550         builder.setUnknownNodes(anyxml.getUnknownSchemaNodes());
551         return builder;
552     }
553
554     /**
555      * Create GroupingBuilder from given GroupingDefinition.
556      *
557      * @param grouping
558      * @param qname
559      * @param moduleName
560      *            current module name
561      * @param line
562      *            current line in module
563      * @return grouping builder based on given grouping node
564      */
565     public static GroupingBuilder createGrouping(GroupingDefinition grouping, QName qname, String moduleName, int line) {
566         final GroupingBuilderImpl builder = new GroupingBuilderImpl(moduleName, line, qname);
567         builder.setPath(grouping.getPath());
568         builder.setChildNodes(grouping.getChildNodes());
569         builder.setGroupings(grouping.getGroupings());
570         builder.setTypedefs(grouping.getTypeDefinitions());
571         builder.setUsesnodes(grouping.getUses());
572         builder.setUnknownNodes(grouping.getUnknownSchemaNodes());
573         builder.setDescription(grouping.getDescription());
574         builder.setReference(grouping.getReference());
575         builder.setStatus(grouping.getStatus());
576         return builder;
577     }
578
579     /**
580      * Create TypeDefinitionBuilder from given ExtendedType.
581      *
582      * @param typedef
583      * @param qname
584      * @param moduleName
585      *            current module name
586      * @param line
587      *            current line in module
588      * @return typedef builder based on given typedef node
589      */
590     public static TypeDefinitionBuilder createTypedef(ExtendedType typedef, QName qname, String moduleName, int line) {
591         final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(moduleName, line, qname);
592         builder.setPath(typedef.getPath());
593         builder.setDefaultValue(typedef.getDefaultValue());
594         builder.setUnits(typedef.getUnits());
595         builder.setDescription(typedef.getDescription());
596         builder.setReference(typedef.getReference());
597         builder.setStatus(typedef.getStatus());
598         builder.setRanges(typedef.getRanges());
599         builder.setLengths(typedef.getLengths());
600         builder.setPatterns(typedef.getPatterns());
601         builder.setFractionDigits(typedef.getFractionDigits());
602         final TypeDefinition<?> type = typedef.getBaseType();
603         builder.setType(type);
604         builder.setUnits(typedef.getUnits());
605         builder.setUnknownNodes(typedef.getUnknownSchemaNodes());
606         return builder;
607     }
608
609     /**
610      * Create UnknownSchemaNodeBuilder from given UnknownSchemaNode.
611      *
612      * @param unknownNode
613      * @param qname
614      * @param moduleName
615      *            current module name
616      * @param line
617      *            current line in module
618      * @return unknown node builder based on given unknown node
619      */
620     public static UnknownSchemaNodeBuilder createUnknownSchemaNode(UnknownSchemaNode unknownNode, QName qname,
621             String moduleName, int line) {
622         final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(moduleName, line, qname);
623         builder.setPath(unknownNode.getPath());
624         builder.setUnknownNodes(unknownNode.getUnknownSchemaNodes());
625         builder.setDescription(unknownNode.getDescription());
626         builder.setReference(unknownNode.getReference());
627         builder.setStatus(unknownNode.getStatus());
628         builder.setAddedByUses(unknownNode.isAddedByUses());
629         builder.setNodeType(unknownNode.getNodeType());
630         builder.setNodeParameter(unknownNode.getNodeParameter());
631         return builder;
632     }
633
634
635     /**
636      * Create LeafSchemaNodeBuilder from given LeafSchemaNode.
637      *
638      * @param leaf
639      *            leaf from which to create builder
640      * @param qname
641      * @param moduleName
642      *            current module name
643      * @param line
644      *            line in module
645      * @return leaf builder based on given leaf node
646      */
647     public static LeafSchemaNodeBuilder createLeafBuilder(LeafSchemaNode leaf, QName qname, String moduleName, int line) {
648         final LeafSchemaNodeBuilder builder = new LeafSchemaNodeBuilder(moduleName, line, qname, leaf.getPath());
649         convertDataSchemaNode(leaf, builder);
650         builder.setConfiguration(leaf.isConfiguration());
651         final TypeDefinition<?> type = leaf.getType();
652         builder.setType(type);
653         builder.setPath(leaf.getPath());
654         builder.setUnknownNodes(leaf.getUnknownSchemaNodes());
655         builder.setDefaultStr(leaf.getDefault());
656         builder.setUnits(leaf.getUnits());
657         return builder;
658     }
659
660     /**
661      * Create ContainerSchemaNodeBuilder from given ContainerSchemaNode.
662      *
663      * @param container
664      * @param qname
665      * @param moduleName
666      *            current module name
667      * @param line
668      *            current line in module
669      * @return container builder based on given container node
670      */
671     public static ContainerSchemaNodeBuilder createContainer(ContainerSchemaNode container, QName qname,
672             String moduleName, int line) {
673         final ContainerSchemaNodeBuilder builder = new ContainerSchemaNodeBuilder(moduleName, line, qname,
674                 container.getPath());
675         convertDataSchemaNode(container, builder);
676         builder.setConfiguration(container.isConfiguration());
677         builder.setUnknownNodes(container.getUnknownSchemaNodes());
678         builder.setChildNodes(container.getChildNodes());
679         builder.setGroupings(container.getGroupings());
680         builder.setTypedefs(container.getTypeDefinitions());
681         builder.setAugmentations(container.getAvailableAugmentations());
682         builder.setUsesnodes(container.getUses());
683         builder.setPresence(container.isPresenceContainer());
684         return builder;
685     }
686
687     /**
688      * Create ListSchemaNodeBuilder from given ListSchemaNode.
689      *
690      * @param list
691      * @param qname
692      * @param moduleName
693      *            current module name
694      * @param line
695      *            current line in module
696      * @return list builder based on given list node
697      */
698     public static ListSchemaNodeBuilder createList(ListSchemaNode list, QName qname, String moduleName, int line) {
699         ListSchemaNodeBuilder builder = new ListSchemaNodeBuilder(moduleName, line, qname, list.getPath());
700         convertDataSchemaNode(list, builder);
701         builder.setConfiguration(list.isConfiguration());
702         builder.setUnknownNodes(list.getUnknownSchemaNodes());
703         builder.setTypedefs(list.getTypeDefinitions());
704         builder.setChildNodes(list.getChildNodes());
705         builder.setGroupings(list.getGroupings());
706         builder.setAugmentations(list.getAvailableAugmentations());
707         builder.setUsesnodes(list.getUses());
708         builder.setUserOrdered(builder.isUserOrdered());
709         return builder;
710     }
711
712     /**
713      * Create LeafListSchemaNodeBuilder from given LeafListSchemaNode.
714      *
715      * @param leafList
716      * @param qname
717      * @param moduleName
718      *            current module name
719      * @param line
720      *            current line in module
721      * @return leaf-list builder based on given leaf-list node
722      */
723     public static LeafListSchemaNodeBuilder createLeafList(LeafListSchemaNode leafList, QName qname, String moduleName,
724             int line) {
725         final LeafListSchemaNodeBuilder builder = new LeafListSchemaNodeBuilder(moduleName, line, qname,
726                 leafList.getPath());
727         convertDataSchemaNode(leafList, builder);
728         builder.setConfiguration(leafList.isConfiguration());
729         builder.setType(leafList.getType());
730         builder.setUnknownNodes(leafList.getUnknownSchemaNodes());
731         builder.setUserOrdered(leafList.isUserOrdered());
732         return builder;
733     }
734
735     /**
736      * Create ChoiceBuilder from given ChoiceNode.
737      *
738      * @param choice
739      * @param qname
740      * @param moduleName
741      *            current module name
742      * @param line
743      *            current line in module
744      * @return choice builder based on given choice node
745      */
746     public static ChoiceBuilder createChoice(ChoiceNode choice, QName qname, String moduleName, int line) {
747         final ChoiceBuilder builder = new ChoiceBuilder(moduleName, line, qname);
748         convertDataSchemaNode(choice, builder);
749         builder.setConfiguration(choice.isConfiguration());
750         builder.setCases(choice.getCases());
751         builder.setUnknownNodes(choice.getUnknownSchemaNodes());
752         builder.setDefaultCase(choice.getDefaultCase());
753         return builder;
754     }
755
756
757     /**
758      * Set DataSchemaNode arguments to builder object
759      *
760      * @param node
761      *            node from which arguments should be read
762      * @param builder
763      *            builder to which arguments should be set
764      */
765     private static void convertDataSchemaNode(DataSchemaNode node, DataSchemaNodeBuilder builder) {
766         builder.setPath(node.getPath());
767         builder.setDescription(node.getDescription());
768         builder.setReference(node.getReference());
769         builder.setStatus(node.getStatus());
770         builder.setAugmenting(node.isAugmenting());
771         copyConstraintsFromDefinition(node.getConstraints(), builder.getConstraints());
772     }
773
774     /**
775      * Copy constraints from constraints definition to constraints builder.
776      *
777      * @param nodeConstraints
778      *            definition from which constraints will be copied
779      * @param constraints
780      *            builder to which constraints will be added
781      */
782     private static void copyConstraintsFromDefinition(final ConstraintDefinition nodeConstraints,
783             final ConstraintsBuilder constraints) {
784         final RevisionAwareXPath when = nodeConstraints.getWhenCondition();
785         final Set<MustDefinition> must = nodeConstraints.getMustConstraints();
786
787         if (when != null) {
788             constraints.addWhenCondition(when.toString());
789         }
790         if (must != null) {
791             for (MustDefinition md : must) {
792                 constraints.addMustDefinition(md);
793             }
794         }
795         constraints.setMandatory(nodeConstraints.isMandatory());
796         constraints.setMinElements(nodeConstraints.getMinElements());
797         constraints.setMaxElements(nodeConstraints.getMaxElements());
798     }
799
800 }