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.ArrayList;
11 import org.opendaylight.yangtools.yang.common.QName;
12 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
13 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
14 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
15 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
16 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
17 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
18 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
19 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
20 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
21 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
22 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
23 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
25 public final class CopyUtils {
31 * Create copy of DataSchemaNodeBuilder with new parent. If updateQName is
32 * true, qname of node will be corrected based on new parent.
39 * flag to indicate if qname should be updated based on new
41 * @return copy of given builder
43 public static DataSchemaNodeBuilder copy(final DataSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
44 if (old instanceof AnyXmlBuilder) {
45 return copy((AnyXmlBuilder) old, newParent, updateQName);
46 } else if (old instanceof ChoiceBuilder) {
47 return copy((ChoiceBuilder) old, newParent, updateQName);
48 } else if (old instanceof ContainerSchemaNodeBuilder) {
49 return copy((ContainerSchemaNodeBuilder) old, newParent, updateQName);
50 } else if (old instanceof LeafSchemaNodeBuilder) {
51 return copy((LeafSchemaNodeBuilder) old, newParent, updateQName);
52 } else if (old instanceof LeafListSchemaNodeBuilder) {
53 return copy((LeafListSchemaNodeBuilder) old, newParent, updateQName);
54 } else if (old instanceof ListSchemaNodeBuilder) {
55 return copy((ListSchemaNodeBuilder) old, newParent, updateQName);
56 } else if (old instanceof ChoiceCaseBuilder) {
57 return copy((ChoiceCaseBuilder) old, newParent, updateQName);
59 throw new YangParseException(old.getModuleName(), old.getLine(),
60 "Failed to copy node: Unknown type of DataSchemaNode: " + old);
64 private static AnyXmlBuilder copy(final AnyXmlBuilder old, final Builder newParent, final boolean updateQName) {
65 DataBean data = getdata(old, newParent, updateQName);
66 QName newQName = data.qname;
67 SchemaPath newSchemaPath = data.schemaPath;
69 AnyXmlBuilder copy = new AnyXmlBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
70 copyConstraints(copy.getConstraints(), old.getConstraints());
71 copy.setParent(newParent);
72 copy.setDescription(old.getDescription());
73 copy.setReference(old.getReference());
74 copy.setStatus(old.getStatus());
75 copy.setAugmenting(old.isAugmenting());
76 copy.setAddedByUses(old.isAddedByUses());
77 copy.setConfiguration(old.isConfiguration());
78 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
79 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
85 private static ChoiceBuilder copy(final ChoiceBuilder old, final Builder newParent, final boolean updateQName) {
86 DataBean data = getdata(old, newParent, updateQName);
87 QName newQName = data.qname;
88 SchemaPath newSchemaPath = data.schemaPath;
90 ChoiceBuilder copy = new ChoiceBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
91 copyConstraints(copy.getConstraints(), old.getConstraints());
92 copy.setParent(newParent);
93 copy.setDescription(old.getDescription());
94 copy.setReference(old.getReference());
95 copy.setStatus(old.getStatus());
96 copy.setAugmenting(old.isAugmenting());
97 copy.setAddedByUses(old.isAddedByUses());
98 copy.setConfiguration(old.isConfiguration());
99 for (ChoiceCaseBuilder childNode : old.getCases()) {
100 copy.addCase(copy(childNode, copy, updateQName));
102 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
103 copy.addAugmentation(copyAugment(augment, copy));
105 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
106 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
112 private static ChoiceCaseBuilder copy(final ChoiceCaseBuilder old, final Builder newParent, final boolean updateQName) {
113 DataBean data = getdata(old, newParent, updateQName);
114 QName newQName = data.qname;
115 SchemaPath newSchemaPath = data.schemaPath;
117 ChoiceCaseBuilder copy = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
118 copyConstraints(copy.getConstraints(), old.getConstraints());
119 copy.setParent(newParent);
120 copy.setDescription(old.getDescription());
121 copy.setReference(old.getReference());
122 copy.setStatus(old.getStatus());
123 copy.setAugmenting(old.isAugmenting());
124 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
125 copy.addChildNode(copy(childNode, copy, updateQName));
127 copy.getGroupings().addAll(old.getGroupings());
128 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
129 copy.addGrouping(copy(grouping, copy, updateQName));
131 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
132 copy.addTypedef(copy(tdb, copy, updateQName));
134 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
135 copy.addUsesNode(copyUses(oldUses, copy));
137 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
138 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
144 private static ContainerSchemaNodeBuilder copy(final ContainerSchemaNodeBuilder old, final Builder newParent,
145 final boolean updateQName) {
146 DataBean data = getdata(old, newParent, updateQName);
147 QName newQName = data.qname;
148 SchemaPath newSchemaPath = data.schemaPath;
150 ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(newParent.getModuleName(),
151 newParent.getLine(), newQName, newSchemaPath);
152 copyConstraints(copy.getConstraints(), old.getConstraints());
153 copy.setParent(newParent);
154 copy.setDescription(old.getDescription());
155 copy.setReference(old.getReference());
156 copy.setStatus(old.getStatus());
157 copy.setPresence(old.isPresence());
158 copy.setAugmenting(old.isAugmenting());
159 copy.setAddedByUses(old.isAddedByUses());
160 copy.setConfiguration(old.isConfiguration());
161 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
162 copy.addChildNode(copy(childNode, copy, updateQName));
164 copy.getGroupings().addAll(old.getGroupings());
165 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
166 copy.addGrouping(copy(grouping, copy, updateQName));
168 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
169 copy.addTypedef(copy(tdb, copy, updateQName));
171 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
172 copy.addUsesNode(copyUses(oldUses, copy));
174 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
175 copy.addAugmentation(copyAugment(augment, copy));
177 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
178 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
184 private static LeafSchemaNodeBuilder copy(final LeafSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
185 DataBean data = getdata(old, newParent, updateQName);
186 QName newQName = data.qname;
187 SchemaPath newSchemaPath = data.schemaPath;
189 LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
190 newQName, newSchemaPath);
191 copyConstraints(copy.getConstraints(), old.getConstraints());
192 copy.setParent(newParent);
193 copy.setDescription(old.getDescription());
194 copy.setReference(old.getReference());
195 copy.setStatus(old.getStatus());
196 copy.setAugmenting(old.isAugmenting());
197 copy.setAddedByUses(old.isAddedByUses());
198 copy.setConfiguration(old.isConfiguration());
199 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
200 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
203 if (old.getType() == null) {
204 copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
206 copy.setType(old.getType());
209 copy.setDefaultStr(old.getDefaultStr());
210 copy.setUnits(old.getUnits());
215 private static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
216 DataBean data = getdata(old, newParent, updateQName);
217 QName newQName = data.qname;
218 SchemaPath newSchemaPath = data.schemaPath;
220 LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
221 newQName, newSchemaPath);
222 copyConstraints(copy.getConstraints(), old.getConstraints());
223 copy.setParent(newParent);
224 copy.setDescription(old.getDescription());
225 copy.setReference(old.getReference());
226 copy.setStatus(old.getStatus());
227 copy.setAugmenting(old.isAugmenting());
228 copy.setAddedByUses(old.isAddedByUses());
229 copy.setConfiguration(old.isConfiguration());
230 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
231 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
234 if (old.getType() == null) {
235 copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
237 copy.setType(old.getType());
240 copy.setUserOrdered(old.isUserOrdered());
245 private static ListSchemaNodeBuilder copy(final ListSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
246 DataBean data = getdata(old, newParent, updateQName);
247 QName newQName = data.qname;
248 SchemaPath newSchemaPath = data.schemaPath;
250 ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
251 newQName, newSchemaPath);
252 copyConstraints(copy.getConstraints(), old.getConstraints());
253 copy.setParent(newParent);
254 copy.setDescription(old.getDescription());
255 copy.setReference(old.getReference());
256 copy.setStatus(old.getStatus());
257 copy.setAugmenting(old.isAugmenting());
258 copy.setAddedByUses(old.isAddedByUses());
259 copy.setConfiguration(old.isConfiguration());
260 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
261 copy.addChildNode(copy(childNode, copy, updateQName));
263 copy.getGroupings().addAll(old.getGroupings());
264 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
265 copy.addGrouping(copy(grouping, copy, updateQName));
267 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
268 copy.addTypedef(copy(tdb, copy, updateQName));
270 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
271 copy.addUsesNode(copyUses(oldUses, copy));
273 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
274 copy.addAugmentation(copyAugment(augment, copy));
276 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
277 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
280 copy.setUserOrdered(old.isUserOrdered());
281 copy.setKeys(old.getKeys());
286 public static GroupingBuilder copy(final GroupingBuilder old, final Builder newParent, final boolean updateQName) {
287 DataBean data = getdata(old, newParent, updateQName);
288 QName newQName = data.qname;
289 SchemaPath newSchemaPath = data.schemaPath;
291 GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
292 copy.setParent(newParent);
293 copy.setDescription(old.getDescription());
294 copy.setReference(old.getReference());
295 copy.setStatus(old.getStatus());
296 copy.setAddedByUses(old.isAddedByUses());
297 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
298 copy.addChildNode(copy(childNode, copy, updateQName));
300 copy.getGroupings().addAll(old.getGroupings());
301 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
302 copy.addGrouping(copy(grouping, copy, updateQName));
304 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
305 copy.addTypedef(copy(tdb, copy, updateQName));
307 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
308 copy.addUsesNode(copyUses(oldUses, copy));
310 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
311 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
317 public static TypeDefinitionBuilder copy(final TypeDefinitionBuilder old, final Builder newParent, final boolean updateQName) {
318 DataBean data = getdata(old, newParent, updateQName);
319 QName newQName = data.qname;
320 SchemaPath newSchemaPath = data.schemaPath;
321 TypeDefinitionBuilder type;
323 if (old instanceof UnionTypeBuilder) {
324 UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
325 type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
326 type.setParent(newParent);
327 for (TypeDefinition<?> td : oldUnion.getTypes()) {
330 for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
331 type.setTypedef(copy(tdb, type, updateQName));
333 } else if (old instanceof IdentityrefTypeBuilder) {
334 type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
335 ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
336 type.setParent(newParent);
338 type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName, old.getPath());
339 type.setParent(newParent);
341 if (old.getType() == null) {
342 type.setTypedef(copy(old.getTypedef(), type, updateQName));
344 type.setType(old.getType());
347 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
348 type.addUnknownNodeBuilder((copy(un, type, updateQName)));
351 type.setRanges(old.getRanges());
352 type.setLengths(old.getLengths());
353 type.setPatterns(old.getPatterns());
354 type.setFractionDigits(old.getFractionDigits());
355 type.setDescription(old.getDescription());
356 type.setReference(old.getReference());
357 type.setStatus(old.getStatus());
358 type.setUnits(old.getUnits());
359 type.setDefaultValue(old.getDefaultValue());
360 type.setAddedByUses(old.isAddedByUses());
366 private static ConstraintsBuilder copyConstraints(final ConstraintsBuilder newConstraints, final ConstraintsBuilder old) {
367 newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
368 newConstraints.addWhenCondition(old.getWhenCondition());
369 newConstraints.setMandatory(old.isMandatory());
370 newConstraints.setMinElements(old.getMinElements());
371 newConstraints.setMaxElements(old.getMaxElements());
372 return newConstraints;
375 private static UsesNodeBuilder copyUses(final UsesNodeBuilder old, final Builder newParent) {
376 UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
377 old.getGroupingPathAsString());
378 copy.setParent(newParent);
379 copy.setGroupingDefinition(old.getGroupingDefinition());
380 copy.setGrouping(old.getGroupingBuilder());
381 copy.setAddedByUses(old.isAddedByUses());
382 copy.getAugmentations().addAll(old.getAugmentations());
383 copy.getRefineNodes().addAll(old.getRefineNodes());
384 copy.getRefines().addAll(old.getRefines());
385 copy.setAugmenting(old.isAugmenting());
389 private static AugmentationSchemaBuilder copyAugment(final AugmentationSchemaBuilder old, final Builder newParent) {
390 AugmentationSchemaBuilderImpl copy = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
391 newParent.getLine(), old.getTargetPathAsString(), old.getOrder());
392 copy.setParent(newParent);
394 copy.setDescription(old.getDescription());
395 copy.setReference(old.getReference());
396 copy.setStatus(old.getStatus());
397 copy.addWhenCondition(old.getWhenCondition());
398 copy.setTargetNodeSchemaPath(old.getTargetNodeSchemaPath());
399 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
400 copy.addChildNode(copy(childNode, copy, false));
402 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
403 copy.addUsesNode(copyUses(oldUses, copy));
405 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
406 copy.addUnknownNodeBuilder((copy(un, copy, false)));
412 public static UnknownSchemaNodeBuilderImpl copy(final UnknownSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
413 DataBean data = getdata(old, newParent, updateQName);
414 QName newQName = data.qname;
415 SchemaPath newSchemaPath = data.schemaPath;
417 UnknownSchemaNodeBuilderImpl c = new UnknownSchemaNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
418 newQName, newSchemaPath);
420 c.setNodeType(old.getNodeType());
421 c.setNodeParameter(old.getNodeParameter());
422 c.setParent(newParent);
423 c.setDescription(old.getDescription());
424 c.setReference(old.getReference());
425 c.setStatus(old.getStatus());
426 c.setAddedByUses(old.isAddedByUses());
427 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
428 c.addUnknownNodeBuilder((copy(un, c, updateQName)));
430 c.setExtensionBuilder(old.getExtensionBuilder());
431 c.setExtensionDefinition(old.getExtensionDefinition());
436 private static DataBean getdata(final SchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
437 final SchemaPath newSchemaPath;
438 QName newQName = null;
439 if (newParent instanceof ModuleBuilder) {
440 ModuleBuilder parent = (ModuleBuilder) newParent;
442 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
445 newQName = old.getQName();
447 newSchemaPath = SchemaPath.create(true, newQName);
448 } else if (newParent instanceof AugmentationSchemaBuilder) {
449 AugmentationSchemaBuilder augment = (AugmentationSchemaBuilder) newParent;
450 ModuleBuilder parent = BuilderUtils.getParentModule(newParent);
452 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
455 newQName = old.getQName();
457 newSchemaPath = augment.getTargetNodeSchemaPath().createChild(newQName);
458 } else if (newParent instanceof SchemaNodeBuilder) {
459 SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
460 QName parentQName = parent.getQName();
462 newQName = new QName(parentQName.getNamespace(), parentQName.getRevision(), parentQName.getPrefix(),
463 old.getQName().getLocalName());
465 newQName = old.getQName();
467 newSchemaPath = parent.getPath().createChild(newQName);
469 newSchemaPath = SchemaPath.ROOT;
472 return new DataBean(newQName, newSchemaPath);
475 private static final class DataBean {
476 private final QName qname;
477 private final SchemaPath schemaPath;
479 private DataBean(final QName qname, final SchemaPath schemaPath) {
481 this.schemaPath = schemaPath;