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 org.opendaylight.yangtools.yang.common.QName;
11 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
12 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
13 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
14 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
15 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
16 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
17 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
18 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
19 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
20 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
21 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
22 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
24 public final class CopyUtils {
30 * Create copy of DataSchemaNodeBuilder with new parent. If updateQName is
31 * true, qname of node will be corrected based on new parent.
38 * flag to indicate if qname should be updated based on new
40 * @return copy of given builder
42 public static DataSchemaNodeBuilder copy(final DataSchemaNodeBuilder old, final Builder newParent,
43 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 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
71 copyConstraints(copy.getConstraints(), old.getConstraints());
72 copy.setParent(newParent);
73 copy.setDescription(old.getDescription());
74 copy.setReference(old.getReference());
75 copy.setStatus(old.getStatus());
76 copy.setAugmenting(old.isAugmenting());
77 copy.setAddedByUses(old.isAddedByUses());
78 copy.setConfiguration(old.isConfiguration());
79 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
80 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
86 private static ChoiceBuilder copy(final ChoiceBuilder old, final Builder newParent, final boolean updateQName) {
87 DataBean data = getdata(old, newParent, updateQName);
88 QName newQName = data.qname;
89 SchemaPath newSchemaPath = data.schemaPath;
91 ChoiceBuilder copy = new ChoiceBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
92 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
93 copyConstraints(copy.getConstraints(), old.getConstraints());
94 copy.setParent(newParent);
95 copy.setDescription(old.getDescription());
96 copy.setReference(old.getReference());
97 copy.setStatus(old.getStatus());
98 copy.setAugmenting(old.isAugmenting());
99 copy.setAddedByUses(old.isAddedByUses());
100 copy.setConfiguration(old.isConfiguration());
101 for (ChoiceCaseBuilder childNode : old.getCases()) {
102 copy.addCase(copy(childNode, copy, updateQName));
104 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
105 copy.addAugmentation(copyAugment(augment, copy));
107 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
108 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
114 private static ChoiceCaseBuilder copy(final ChoiceCaseBuilder old, final Builder newParent,
115 final boolean updateQName) {
116 DataBean data = getdata(old, newParent, updateQName);
117 QName newQName = data.qname;
118 SchemaPath newSchemaPath = data.schemaPath;
120 ChoiceCaseBuilder copy = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName,
122 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
123 copyConstraints(copy.getConstraints(), old.getConstraints());
124 copy.setParent(newParent);
125 copy.setDescription(old.getDescription());
126 copy.setReference(old.getReference());
127 copy.setStatus(old.getStatus());
128 copy.setAugmenting(old.isAugmenting());
129 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
130 copy.addChildNode(copy(childNode, copy, updateQName));
132 copy.getGroupings().addAll(old.getGroupings());
133 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
134 copy.addGrouping(copy(grouping, copy, updateQName));
136 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
137 copy.addTypedef(copy(tdb, copy, updateQName));
139 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
140 copy.addUsesNode(copyUses(oldUses, copy));
142 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
143 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
149 private static ContainerSchemaNodeBuilder copy(final ContainerSchemaNodeBuilder old, final Builder newParent,
150 final boolean updateQName) {
151 DataBean data = getdata(old, newParent, updateQName);
152 QName newQName = data.qname;
153 SchemaPath newSchemaPath = data.schemaPath;
155 ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(newParent.getModuleName(),
156 newParent.getLine(), newQName, newSchemaPath);
157 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
158 copyConstraints(copy.getConstraints(), old.getConstraints());
159 copy.setParent(newParent);
160 copy.setDescription(old.getDescription());
161 copy.setReference(old.getReference());
162 copy.setStatus(old.getStatus());
163 copy.setPresence(old.isPresence());
164 copy.setAugmenting(old.isAugmenting());
165 copy.setAddedByUses(old.isAddedByUses());
166 copy.setConfiguration(old.isConfiguration());
167 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
168 copy.addChildNode(copy(childNode, copy, updateQName));
170 copy.getGroupings().addAll(old.getGroupings());
171 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
172 copy.addGrouping(copy(grouping, copy, updateQName));
174 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
175 copy.addTypedef(copy(tdb, copy, updateQName));
177 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
178 copy.addUsesNode(copyUses(oldUses, copy));
180 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
181 copy.addAugmentation(copyAugment(augment, copy));
183 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
184 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
190 private static LeafSchemaNodeBuilder copy(final LeafSchemaNodeBuilder old, final Builder newParent,
191 final boolean updateQName) {
192 DataBean data = getdata(old, newParent, updateQName);
193 QName newQName = data.qname;
194 SchemaPath newSchemaPath = data.schemaPath;
196 LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
197 newQName, newSchemaPath);
198 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
199 copyConstraints(copy.getConstraints(), old.getConstraints());
200 copy.setParent(newParent);
201 copy.setDescription(old.getDescription());
202 copy.setReference(old.getReference());
203 copy.setStatus(old.getStatus());
204 copy.setAugmenting(old.isAugmenting());
205 copy.setAddedByUses(old.isAddedByUses());
206 copy.setConfiguration(old.isConfiguration());
207 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
208 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
211 if (old.getType() == null) {
212 copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
214 copy.setType(old.getType());
217 copy.setDefaultStr(old.getDefaultStr());
218 copy.setUnits(old.getUnits());
223 private static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent,
224 final boolean updateQName) {
225 DataBean data = getdata(old, newParent, updateQName);
226 QName newQName = data.qname;
227 SchemaPath newSchemaPath = data.schemaPath;
229 LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
230 newQName, newSchemaPath);
231 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
232 copyConstraints(copy.getConstraints(), old.getConstraints());
233 copy.setParent(newParent);
234 copy.setDescription(old.getDescription());
235 copy.setReference(old.getReference());
236 copy.setStatus(old.getStatus());
237 copy.setAugmenting(old.isAugmenting());
238 copy.setAddedByUses(old.isAddedByUses());
239 copy.setConfiguration(old.isConfiguration());
240 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
241 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
244 if (old.getType() == null) {
245 copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
247 copy.setType(old.getType());
250 copy.setUserOrdered(old.isUserOrdered());
255 private static ListSchemaNodeBuilder copy(final ListSchemaNodeBuilder old, final Builder newParent,
256 final boolean updateQName) {
257 DataBean data = getdata(old, newParent, updateQName);
258 QName newQName = data.qname;
259 SchemaPath newSchemaPath = data.schemaPath;
261 ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
262 newQName, newSchemaPath);
263 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
264 copyConstraints(copy.getConstraints(), old.getConstraints());
265 copy.setParent(newParent);
266 copy.setDescription(old.getDescription());
267 copy.setReference(old.getReference());
268 copy.setStatus(old.getStatus());
269 copy.setAugmenting(old.isAugmenting());
270 copy.setAddedByUses(old.isAddedByUses());
271 copy.setConfiguration(old.isConfiguration());
272 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
273 copy.addChildNode(copy(childNode, copy, updateQName));
275 copy.getGroupings().addAll(old.getGroupings());
276 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
277 copy.addGrouping(copy(grouping, copy, updateQName));
279 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
280 copy.addTypedef(copy(tdb, copy, updateQName));
282 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
283 copy.addUsesNode(copyUses(oldUses, copy));
285 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
286 copy.addAugmentation(copyAugment(augment, copy));
288 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
289 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
292 copy.setUserOrdered(old.isUserOrdered());
293 copy.setKeys(old.getKeys());
298 public static GroupingBuilder copy(final GroupingBuilder old, final Builder newParent, final boolean updateQName) {
299 DataBean data = getdata(old, newParent, updateQName);
300 QName newQName = data.qname;
301 SchemaPath newSchemaPath = data.schemaPath;
303 GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName,
305 copy.setParent(newParent);
306 copy.setDescription(old.getDescription());
307 copy.setReference(old.getReference());
308 copy.setStatus(old.getStatus());
309 copy.setAddedByUses(old.isAddedByUses());
310 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
311 copy.addChildNode(copy(childNode, copy, updateQName));
313 copy.getGroupings().addAll(old.getGroupings());
314 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
315 copy.addGrouping(copy(grouping, copy, updateQName));
317 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
318 copy.addTypedef(copy(tdb, copy, updateQName));
320 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
321 copy.addUsesNode(copyUses(oldUses, copy));
323 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
324 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
330 public static TypeDefinitionBuilder copy(final TypeDefinitionBuilder old, final Builder newParent,
331 final boolean updateQName) {
332 DataBean data = getdata(old, newParent, updateQName);
333 QName newQName = data.qname;
334 SchemaPath newSchemaPath = data.schemaPath;
335 TypeDefinitionBuilder type;
337 if (old instanceof UnionTypeBuilder) {
338 UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
339 type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
340 type.setParent(newParent);
341 for (TypeDefinition<?> td : oldUnion.getTypes()) {
344 for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
345 type.setTypedef(copy(tdb, type, updateQName));
347 } else if (old instanceof IdentityrefTypeBuilder) {
348 type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
349 ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
350 type.setParent(newParent);
352 type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName, old.getPath());
353 type.setParent(newParent);
355 if (old.getType() == null) {
356 type.setTypedef(copy(old.getTypedef(), type, updateQName));
358 type.setType(old.getType());
361 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
362 type.addUnknownNodeBuilder((copy(un, type, updateQName)));
365 type.setRanges(old.getRanges());
366 type.setLengths(old.getLengths());
367 type.setPatterns(old.getPatterns());
368 type.setFractionDigits(old.getFractionDigits());
369 type.setDescription(old.getDescription());
370 type.setReference(old.getReference());
371 type.setStatus(old.getStatus());
372 type.setUnits(old.getUnits());
373 type.setDefaultValue(old.getDefaultValue());
374 type.setAddedByUses(old.isAddedByUses());
380 private static ConstraintsBuilder copyConstraints(final ConstraintsBuilder newConstraints,
381 final ConstraintsBuilder old) {
382 newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
383 newConstraints.addWhenCondition(old.getWhenCondition());
384 newConstraints.setMandatory(old.isMandatory());
385 newConstraints.setMinElements(old.getMinElements());
386 newConstraints.setMaxElements(old.getMaxElements());
387 return newConstraints;
390 private static UsesNodeBuilder copyUses(final UsesNodeBuilder old, final Builder newParent) {
391 UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
392 old.getGroupingPathAsString());
393 copy.setParent(newParent);
394 copy.setGroupingDefinition(old.getGroupingDefinition());
395 copy.setGrouping(old.getGroupingBuilder());
396 copy.setAddedByUses(old.isAddedByUses());
397 copy.getAugmentations().addAll(old.getAugmentations());
398 copy.getRefineNodes().addAll(old.getRefineNodes());
399 copy.getRefines().addAll(old.getRefines());
400 copy.setAugmenting(old.isAugmenting());
404 private static AugmentationSchemaBuilder copyAugment(final AugmentationSchemaBuilder old, final Builder newParent) {
405 AugmentationSchemaBuilderImpl copy = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
406 newParent.getLine(), old.getTargetPathAsString(), old.getOrder());
407 copy.setParent(newParent);
409 copy.setDescription(old.getDescription());
410 copy.setReference(old.getReference());
411 copy.setStatus(old.getStatus());
412 copy.addWhenCondition(old.getWhenCondition());
413 copy.setTargetNodeSchemaPath(old.getTargetNodeSchemaPath());
414 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
415 copy.addChildNode(copy(childNode, copy, false));
417 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
418 copy.addUsesNode(copyUses(oldUses, copy));
420 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
421 copy.addUnknownNodeBuilder((copy(un, copy, false)));
427 public static UnknownSchemaNodeBuilderImpl copy(final UnknownSchemaNodeBuilder old, final Builder newParent,
428 final boolean updateQName) {
429 DataBean data = getdata(old, newParent, updateQName);
430 QName newQName = data.qname;
431 SchemaPath newSchemaPath = data.schemaPath;
433 UnknownSchemaNodeBuilderImpl c = new UnknownSchemaNodeBuilderImpl(newParent.getModuleName(),
434 newParent.getLine(), newQName, newSchemaPath);
436 c.setNodeType(old.getNodeType());
437 c.setNodeParameter(old.getNodeParameter());
438 c.setParent(newParent);
439 c.setDescription(old.getDescription());
440 c.setReference(old.getReference());
441 c.setStatus(old.getStatus());
442 c.setAddedByUses(old.isAddedByUses());
443 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
444 c.addUnknownNodeBuilder((copy(un, c, updateQName)));
446 c.setExtensionBuilder(old.getExtensionBuilder());
447 c.setExtensionDefinition(old.getExtensionDefinition());
452 private static DataBean getdata(final SchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
453 final SchemaPath newSchemaPath;
454 QName newQName = null;
455 if (newParent instanceof ModuleBuilder) {
456 ModuleBuilder parent = (ModuleBuilder) newParent;
458 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
461 newQName = old.getQName();
463 newSchemaPath = SchemaPath.create(true, newQName);
464 } else if (newParent instanceof AugmentationSchemaBuilder) {
465 AugmentationSchemaBuilder augment = (AugmentationSchemaBuilder) newParent;
466 ModuleBuilder parent = BuilderUtils.getParentModule(newParent);
468 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
471 newQName = old.getQName();
473 newSchemaPath = augment.getTargetNodeSchemaPath().createChild(newQName);
474 } else if (newParent instanceof SchemaNodeBuilder) {
475 SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
476 QName parentQName = parent.getQName();
478 newQName = QName.create(parentQName, old.getQName().getLocalName());
480 newQName = old.getQName();
482 newSchemaPath = parent.getPath().createChild(newQName);
484 newSchemaPath = SchemaPath.ROOT;
487 return new DataBean(newQName, newSchemaPath);
490 private static final class DataBean {
491 private final QName qname;
492 private final SchemaPath schemaPath;
494 private DataBean(final QName qname, final SchemaPath schemaPath) {
496 this.schemaPath = schemaPath;