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 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
133 copy.addUsesNode(copyUses(oldUses, copy));
135 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
136 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
142 private static ContainerSchemaNodeBuilder copy(final ContainerSchemaNodeBuilder old, final Builder newParent,
143 final boolean updateQName) {
144 DataBean data = getdata(old, newParent, updateQName);
145 QName newQName = data.qname;
146 SchemaPath newSchemaPath = data.schemaPath;
148 ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(newParent.getModuleName(),
149 newParent.getLine(), newQName, newSchemaPath);
150 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
151 copyConstraints(copy.getConstraints(), old.getConstraints());
152 copy.setParent(newParent);
153 copy.setDescription(old.getDescription());
154 copy.setReference(old.getReference());
155 copy.setStatus(old.getStatus());
156 copy.setPresence(old.isPresence());
157 copy.setAugmenting(old.isAugmenting());
158 copy.setAddedByUses(old.isAddedByUses());
159 copy.setConfiguration(old.isConfiguration());
160 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
161 copy.addChildNode(copy(childNode, copy, updateQName));
163 copy.getGroupings().addAll(old.getGroupings());
164 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
165 copy.addGrouping(copy(grouping, copy, updateQName));
167 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
168 copy.addTypedef(copy(tdb, copy, updateQName));
170 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
171 copy.addUsesNode(copyUses(oldUses, copy));
173 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
174 copy.addAugmentation(copyAugment(augment, copy));
176 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
177 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
183 private static LeafSchemaNodeBuilder copy(final LeafSchemaNodeBuilder old, final Builder newParent,
184 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 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
192 copyConstraints(copy.getConstraints(), old.getConstraints());
193 copy.setParent(newParent);
194 copy.setDescription(old.getDescription());
195 copy.setReference(old.getReference());
196 copy.setStatus(old.getStatus());
197 copy.setAugmenting(old.isAugmenting());
198 copy.setAddedByUses(old.isAddedByUses());
199 copy.setConfiguration(old.isConfiguration());
200 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
201 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
204 if (old.getType() == null) {
205 copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
207 copy.setType(old.getType());
210 copy.setDefaultStr(old.getDefaultStr());
211 copy.setUnits(old.getUnits());
216 private static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent,
217 final boolean updateQName) {
218 DataBean data = getdata(old, newParent, updateQName);
219 QName newQName = data.qname;
220 SchemaPath newSchemaPath = data.schemaPath;
222 LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
223 newQName, newSchemaPath);
224 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
225 copyConstraints(copy.getConstraints(), old.getConstraints());
226 copy.setParent(newParent);
227 copy.setDescription(old.getDescription());
228 copy.setReference(old.getReference());
229 copy.setStatus(old.getStatus());
230 copy.setAugmenting(old.isAugmenting());
231 copy.setAddedByUses(old.isAddedByUses());
232 copy.setConfiguration(old.isConfiguration());
233 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
234 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
237 if (old.getType() == null) {
238 copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
240 copy.setType(old.getType());
243 copy.setUserOrdered(old.isUserOrdered());
248 private static ListSchemaNodeBuilder copy(final ListSchemaNodeBuilder old, final Builder newParent,
249 final boolean updateQName) {
250 DataBean data = getdata(old, newParent, updateQName);
251 QName newQName = data.qname;
252 SchemaPath newSchemaPath = data.schemaPath;
254 ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
255 newQName, newSchemaPath);
256 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
257 copyConstraints(copy.getConstraints(), old.getConstraints());
258 copy.setParent(newParent);
259 copy.setDescription(old.getDescription());
260 copy.setReference(old.getReference());
261 copy.setStatus(old.getStatus());
262 copy.setAugmenting(old.isAugmenting());
263 copy.setAddedByUses(old.isAddedByUses());
264 copy.setConfiguration(old.isConfiguration());
265 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
266 copy.addChildNode(copy(childNode, copy, updateQName));
268 copy.getGroupings().addAll(old.getGroupings());
269 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
270 copy.addGrouping(copy(grouping, copy, updateQName));
272 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
273 copy.addTypedef(copy(tdb, copy, updateQName));
275 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
276 copy.addUsesNode(copyUses(oldUses, copy));
278 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
279 copy.addAugmentation(copyAugment(augment, copy));
281 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
282 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
285 copy.setUserOrdered(old.isUserOrdered());
286 copy.setKeys(old.getKeys());
291 public static GroupingBuilder copy(final GroupingBuilder old, final Builder newParent, final boolean updateQName) {
292 DataBean data = getdata(old, newParent, updateQName);
293 QName newQName = data.qname;
294 SchemaPath newSchemaPath = data.schemaPath;
296 GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName,
298 copy.setParent(newParent);
299 copy.setDescription(old.getDescription());
300 copy.setReference(old.getReference());
301 copy.setStatus(old.getStatus());
302 copy.setAddedByUses(old.isAddedByUses());
303 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
304 copy.addChildNode(copy(childNode, copy, updateQName));
306 copy.getGroupings().addAll(old.getGroupings());
307 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
308 copy.addGrouping(copy(grouping, copy, updateQName));
310 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
311 copy.addTypedef(copy(tdb, copy, updateQName));
313 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
314 copy.addUsesNode(copyUses(oldUses, copy));
316 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
317 copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
323 public static TypeDefinitionBuilder copy(final TypeDefinitionBuilder old, final Builder newParent,
324 final boolean updateQName) {
325 DataBean data = getdata(old, newParent, updateQName);
326 QName newQName = data.qname;
327 SchemaPath newSchemaPath = data.schemaPath;
328 TypeDefinitionBuilder type;
330 if (old instanceof UnionTypeBuilder) {
331 UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
332 type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
333 type.setParent(newParent);
334 for (TypeDefinition<?> td : oldUnion.getTypes()) {
337 for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
338 type.setTypedef(copy(tdb, type, updateQName));
340 } else if (old instanceof IdentityrefTypeBuilder) {
341 type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
342 ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
343 type.setParent(newParent);
345 type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName, old.getPath());
346 type.setParent(newParent);
348 if (old.getType() == null) {
349 type.setTypedef(copy(old.getTypedef(), type, updateQName));
351 type.setType(old.getType());
354 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
355 type.addUnknownNodeBuilder((copy(un, type, updateQName)));
358 type.setRanges(old.getRanges());
359 type.setLengths(old.getLengths());
360 type.setPatterns(old.getPatterns());
361 type.setFractionDigits(old.getFractionDigits());
362 type.setDescription(old.getDescription());
363 type.setReference(old.getReference());
364 type.setStatus(old.getStatus());
365 type.setUnits(old.getUnits());
366 type.setDefaultValue(old.getDefaultValue());
367 type.setAddedByUses(old.isAddedByUses());
373 private static ConstraintsBuilder copyConstraints(final ConstraintsBuilder newConstraints,
374 final ConstraintsBuilder old) {
375 newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
376 newConstraints.addWhenCondition(old.getWhenCondition());
377 newConstraints.setMandatory(old.isMandatory());
378 newConstraints.setMinElements(old.getMinElements());
379 newConstraints.setMaxElements(old.getMaxElements());
380 return newConstraints;
383 private static UsesNodeBuilder copyUses(final UsesNodeBuilder old, final Builder newParent) {
384 UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
385 old.getGroupingPath());
386 copy.setParent(newParent);
387 copy.setGroupingDefinition(old.getGroupingDefinition());
388 copy.setGrouping(old.getGroupingBuilder());
389 copy.setAddedByUses(old.isAddedByUses());
390 copy.getAugmentations().addAll(old.getAugmentations());
391 copy.getRefineNodes().addAll(old.getRefineNodes());
392 copy.getRefines().addAll(old.getRefines());
393 copy.setAugmenting(old.isAugmenting());
397 private static AugmentationSchemaBuilder copyAugment(final AugmentationSchemaBuilder old, final Builder newParent) {
398 AugmentationSchemaBuilderImpl copy = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
399 newParent.getLine(), old.getTargetPathAsString(), old.getTargetPath(), old.getOrder());
400 copy.setParent(newParent);
402 copy.setDescription(old.getDescription());
403 copy.setReference(old.getReference());
404 copy.setStatus(old.getStatus());
405 copy.addWhenCondition(old.getWhenCondition());
406 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
407 copy.addChildNode(copy(childNode, copy, false));
409 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
410 copy.addUsesNode(copyUses(oldUses, copy));
412 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
413 copy.addUnknownNodeBuilder((copy(un, copy, false)));
419 public static UnknownSchemaNodeBuilderImpl copy(final UnknownSchemaNodeBuilder old, final Builder newParent,
420 final boolean updateQName) {
421 DataBean data = getdata(old, newParent, updateQName);
422 QName newQName = data.qname;
423 SchemaPath newSchemaPath = data.schemaPath;
425 UnknownSchemaNodeBuilderImpl c = new UnknownSchemaNodeBuilderImpl(newParent.getModuleName(),
426 newParent.getLine(), newQName, newSchemaPath);
428 c.setNodeType(old.getNodeType());
429 c.setNodeParameter(old.getNodeParameter());
430 c.setParent(newParent);
431 c.setDescription(old.getDescription());
432 c.setReference(old.getReference());
433 c.setStatus(old.getStatus());
434 c.setAddedByUses(old.isAddedByUses());
435 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
436 c.addUnknownNodeBuilder((copy(un, c, updateQName)));
438 c.setExtensionBuilder(old.getExtensionBuilder());
439 c.setExtensionDefinition(old.getExtensionDefinition());
444 private static DataBean getdata(final SchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
445 final SchemaPath newSchemaPath;
446 // this check avoid NPE because if old is IdentityrefTypeBuilder, old.getQNname() return null
447 final boolean identityrefTypeCheck = old instanceof IdentityrefTypeBuilder ? false : updateQName;
449 QName newQName = null;
450 if (newParent instanceof ModuleBuilder) {
451 ModuleBuilder parent = (ModuleBuilder) newParent;
452 if (identityrefTypeCheck) {
453 newQName = QName.create(parent.getQNameModule(), parent.getPrefix(), old.getQName()
456 newQName = old.getQName();
458 newSchemaPath = SchemaPath.create(true, newQName);
459 } else if (newParent instanceof AugmentationSchemaBuilder) {
460 AugmentationSchemaBuilder augment = (AugmentationSchemaBuilder) newParent;
461 ModuleBuilder parent = BuilderUtils.getParentModule(newParent);
462 if (identityrefTypeCheck) {
463 newQName = QName.create(parent.getQNameModule(), parent.getPrefix(), old.getQName()
466 newQName = old.getQName();
468 newSchemaPath = augment.getTargetPath().createChild(newQName);
469 } else if (newParent instanceof SchemaNodeBuilder) {
470 SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
471 QName parentQName = parent.getQName();
472 if (identityrefTypeCheck) {
473 newQName = QName.create(parentQName, old.getQName().getLocalName());
475 newQName = old.getQName();
477 newSchemaPath = parent.getPath().createChild(newQName);
479 newSchemaPath = SchemaPath.ROOT;
482 return new DataBean(newQName, newSchemaPath);
485 private static final class DataBean {
486 private final QName qname;
487 private final SchemaPath schemaPath;
489 private DataBean(final QName qname, final SchemaPath schemaPath) {
491 this.schemaPath = schemaPath;