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;
25 * @deprecated Pre-Beryllium implementation, scheduled for removal.
28 public final class CopyUtils {
34 * Create copy of DataSchemaNodeBuilder with new parent. If updateQName is
35 * true, qname of node will be corrected based on new parent.
42 * flag to indicate if qname should be updated based on new
44 * @return copy of given builder
46 public static DataSchemaNodeBuilder copy(final DataSchemaNodeBuilder old, final Builder newParent,
47 final boolean updateQName) {
48 if (old instanceof AnyXmlBuilder) {
49 return copy((AnyXmlBuilder) old, newParent, updateQName);
50 } else if (old instanceof ChoiceBuilder) {
51 return copy((ChoiceBuilder) old, newParent, updateQName);
52 } else if (old instanceof ContainerSchemaNodeBuilder) {
53 return copy((ContainerSchemaNodeBuilder) old, newParent, updateQName);
54 } else if (old instanceof LeafSchemaNodeBuilder) {
55 return copy((LeafSchemaNodeBuilder) old, newParent, updateQName);
56 } else if (old instanceof LeafListSchemaNodeBuilder) {
57 return copy((LeafListSchemaNodeBuilder) old, newParent, updateQName);
58 } else if (old instanceof ListSchemaNodeBuilder) {
59 return copy((ListSchemaNodeBuilder) old, newParent, updateQName);
60 } else if (old instanceof ChoiceCaseBuilder) {
61 return copy((ChoiceCaseBuilder) old, newParent, updateQName);
63 throw new YangParseException(old.getModuleName(), old.getLine(),
64 "Failed to copy node: Unknown type of DataSchemaNode: " + old);
68 private static AnyXmlBuilder copy(final AnyXmlBuilder old, final Builder newParent, final boolean updateQName) {
69 DataBean data = getdata(old, newParent, updateQName);
70 QName newQName = data.qname;
71 SchemaPath newSchemaPath = data.schemaPath;
73 AnyXmlBuilder copy = new AnyXmlBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
74 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
75 copyConstraints(copy.getConstraints(), old.getConstraints());
76 copy.setParent(newParent);
77 copy.setDescription(old.getDescription());
78 copy.setReference(old.getReference());
79 copy.setStatus(old.getStatus());
80 copy.setAugmenting(old.isAugmenting());
81 copy.setAddedByUses(old.isAddedByUses());
82 copy.setConfiguration(old.isConfiguration());
83 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
84 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
90 private static ChoiceBuilder copy(final ChoiceBuilder old, final Builder newParent, final boolean updateQName) {
91 DataBean data = getdata(old, newParent, updateQName);
92 QName newQName = data.qname;
93 SchemaPath newSchemaPath = data.schemaPath;
95 ChoiceBuilder copy = new ChoiceBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
96 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
97 copyConstraints(copy.getConstraints(), old.getConstraints());
98 copy.setParent(newParent);
99 copy.setDescription(old.getDescription());
100 copy.setReference(old.getReference());
101 copy.setStatus(old.getStatus());
102 copy.setAugmenting(old.isAugmenting());
103 copy.setAddedByUses(old.isAddedByUses());
104 copy.setConfiguration(old.isConfiguration());
105 for (ChoiceCaseBuilder childNode : old.getCases()) {
106 copy.addCase(copy(childNode, copy, updateQName));
108 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
109 copy.addAugmentation(copyAugment(augment, copy));
111 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
112 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
118 private static ChoiceCaseBuilder copy(final ChoiceCaseBuilder old, final Builder newParent,
119 final boolean updateQName) {
120 DataBean data = getdata(old, newParent, updateQName);
121 QName newQName = data.qname;
122 SchemaPath newSchemaPath = data.schemaPath;
124 ChoiceCaseBuilder copy = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName,
126 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
127 copyConstraints(copy.getConstraints(), old.getConstraints());
128 copy.setParent(newParent);
129 copy.setDescription(old.getDescription());
130 copy.setReference(old.getReference());
131 copy.setStatus(old.getStatus());
132 copy.setAugmenting(old.isAugmenting());
133 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
134 copy.addChildNode(copy(childNode, copy, updateQName));
136 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
137 copy.addUsesNode(copyUses(oldUses, copy));
139 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
140 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
146 private static ContainerSchemaNodeBuilder copy(final ContainerSchemaNodeBuilder old, final Builder newParent,
147 final boolean updateQName) {
148 DataBean data = getdata(old, newParent, updateQName);
149 QName newQName = data.qname;
150 SchemaPath newSchemaPath = data.schemaPath;
152 ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(newParent.getModuleName(),
153 newParent.getLine(), newQName, newSchemaPath);
154 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
155 copyConstraints(copy.getConstraints(), old.getConstraints());
156 copy.setParent(newParent);
157 copy.setDescription(old.getDescription());
158 copy.setReference(old.getReference());
159 copy.setStatus(old.getStatus());
160 copy.setPresence(old.isPresence());
161 copy.setAugmenting(old.isAugmenting());
162 copy.setAddedByUses(old.isAddedByUses());
163 copy.setConfiguration(old.isConfiguration());
164 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
165 copy.addChildNode(copy(childNode, copy, updateQName));
167 copy.getGroupings().addAll(old.getGroupings());
168 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
169 copy.addGrouping(copy(grouping, copy, updateQName));
171 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
172 copy.addTypedef(copy(tdb, copy, updateQName));
174 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
175 copy.addUsesNode(copyUses(oldUses, copy));
177 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
178 copy.addAugmentation(copyAugment(augment, copy));
180 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
181 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
187 private static LeafSchemaNodeBuilder copy(final LeafSchemaNodeBuilder old, final Builder newParent,
188 final boolean updateQName) {
189 DataBean data = getdata(old, newParent, updateQName);
190 QName newQName = data.qname;
191 SchemaPath newSchemaPath = data.schemaPath;
193 LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
194 newQName, newSchemaPath);
195 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
196 copyConstraints(copy.getConstraints(), old.getConstraints());
197 copy.setParent(newParent);
198 copy.setDescription(old.getDescription());
199 copy.setReference(old.getReference());
200 copy.setStatus(old.getStatus());
201 copy.setAugmenting(old.isAugmenting());
202 copy.setAddedByUses(old.isAddedByUses());
203 copy.setConfiguration(old.isConfiguration());
204 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
205 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
208 if (old.getType() == null) {
209 copy.setTypedef(old.getTypedef());
211 copy.setType(old.getType());
214 copy.setDefaultStr(old.getDefaultStr());
215 copy.setUnits(old.getUnits());
220 private static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent,
221 final boolean updateQName) {
222 DataBean data = getdata(old, newParent, updateQName);
223 QName newQName = data.qname;
224 SchemaPath newSchemaPath = data.schemaPath;
226 LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
227 newQName, newSchemaPath);
228 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
229 copyConstraints(copy.getConstraints(), old.getConstraints());
230 copy.setParent(newParent);
231 copy.setDescription(old.getDescription());
232 copy.setReference(old.getReference());
233 copy.setStatus(old.getStatus());
234 copy.setAugmenting(old.isAugmenting());
235 copy.setAddedByUses(old.isAddedByUses());
236 copy.setConfiguration(old.isConfiguration());
237 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
238 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
241 if (old.getType() == null) {
242 copy.setTypedef(old.getTypedef());
244 copy.setType(old.getType());
247 copy.setUserOrdered(old.isUserOrdered());
252 private static ListSchemaNodeBuilder copy(final ListSchemaNodeBuilder old, final Builder newParent,
253 final boolean updateQName) {
254 DataBean data = getdata(old, newParent, updateQName);
255 QName newQName = data.qname;
256 SchemaPath newSchemaPath = data.schemaPath;
258 ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
259 newQName, newSchemaPath);
260 copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
261 copyConstraints(copy.getConstraints(), old.getConstraints());
262 copy.setParent(newParent);
263 copy.setDescription(old.getDescription());
264 copy.setReference(old.getReference());
265 copy.setStatus(old.getStatus());
266 copy.setAugmenting(old.isAugmenting());
267 copy.setAddedByUses(old.isAddedByUses());
268 copy.setConfiguration(old.isConfiguration());
269 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
270 copy.addChildNode(copy(childNode, copy, updateQName));
272 copy.getGroupings().addAll(old.getGroupings());
273 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
274 copy.addGrouping(copy(grouping, copy, updateQName));
276 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
277 copy.addTypedef(copy(tdb, copy, updateQName));
279 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
280 copy.addUsesNode(copyUses(oldUses, copy));
282 for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
283 copy.addAugmentation(copyAugment(augment, copy));
285 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
286 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
289 copy.setUserOrdered(old.isUserOrdered());
290 copy.setKeys(old.getKeys());
295 public static GroupingBuilder copy(final GroupingBuilder old, final Builder newParent, final boolean updateQName) {
296 DataBean data = getdata(old, newParent, updateQName);
297 QName newQName = data.qname;
298 SchemaPath newSchemaPath = data.schemaPath;
300 GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName,
302 copy.setParent(newParent);
303 copy.setDescription(old.getDescription());
304 copy.setReference(old.getReference());
305 copy.setStatus(old.getStatus());
306 copy.setAddedByUses(old.isAddedByUses());
307 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
308 copy.addChildNode(copy(childNode, copy, updateQName));
310 copy.getGroupings().addAll(old.getGroupings());
311 for (GroupingBuilder grouping : old.getGroupingBuilders()) {
312 copy.addGrouping(copy(grouping, copy, updateQName));
314 for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
315 copy.addTypedef(copy(tdb, copy, updateQName));
317 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
318 copy.addUsesNode(copyUses(oldUses, copy));
320 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
321 copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
327 public static TypeDefinitionBuilder copy(final TypeDefinitionBuilder old, final Builder newParent,
328 final boolean updateQName) {
329 DataBean data = getdata(old, newParent, updateQName);
330 QName newQName = data.qname;
331 SchemaPath newSchemaPath = data.schemaPath;
332 TypeDefinitionBuilder type;
334 if (old instanceof UnionTypeBuilder) {
335 UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
336 type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
337 type.setParent(newParent);
338 for (TypeDefinition<?> td : oldUnion.getTypes()) {
341 for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
342 type.setTypedef(copy(tdb, type, updateQName));
344 } else if (old instanceof IdentityrefTypeBuilder) {
345 type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
346 ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
347 type.setParent(newParent);
349 type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName, old.getPath());
350 type.setParent(newParent);
352 if (old.getType() == null) {
353 type.setTypedef(copy(old.getTypedef(), type, updateQName));
355 type.setType(old.getType());
358 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
359 type.addUnknownNodeBuilder(copy(un, type, updateQName));
362 type.setRanges(old.getRanges());
363 type.setLengths(old.getLengths());
364 type.setPatterns(old.getPatterns());
365 type.setFractionDigits(old.getFractionDigits());
366 type.setDescription(old.getDescription());
367 type.setReference(old.getReference());
368 type.setStatus(old.getStatus());
369 type.setUnits(old.getUnits());
370 type.setDefaultValue(old.getDefaultValue());
371 type.setAddedByUses(old.isAddedByUses());
377 private static ConstraintsBuilder copyConstraints(final ConstraintsBuilder newConstraints,
378 final ConstraintsBuilder old) {
379 newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
380 newConstraints.addWhenCondition(old.getWhenCondition());
381 newConstraints.setMandatory(old.isMandatory());
382 newConstraints.setMinElements(old.getMinElements());
383 newConstraints.setMaxElements(old.getMaxElements());
384 return newConstraints;
387 private static UsesNodeBuilder copyUses(final UsesNodeBuilder old, final Builder newParent) {
388 UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
389 old.getGroupingPath());
390 copy.setParent(newParent);
391 copy.setGroupingDefinition(old.getGroupingDefinition());
392 copy.setGrouping(old.getGroupingBuilder());
393 copy.setAddedByUses(old.isAddedByUses());
394 copy.getAugmentations().addAll(old.getAugmentations());
395 copy.getRefineNodes().addAll(old.getRefineNodes());
396 copy.getRefines().addAll(old.getRefines());
397 copy.setAugmenting(old.isAugmenting());
401 private static AugmentationSchemaBuilder copyAugment(final AugmentationSchemaBuilder old, final Builder newParent) {
402 AugmentationSchemaBuilderImpl copy = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
403 newParent.getLine(), old.getTargetPathAsString(), old.getTargetPath(), old.getOrder());
404 copy.setParent(newParent);
406 copy.setDescription(old.getDescription());
407 copy.setReference(old.getReference());
408 copy.setStatus(old.getStatus());
409 copy.addWhenCondition(old.getWhenCondition());
410 for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
411 copy.addChildNode(copy(childNode, copy, false));
413 for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
414 copy.addUsesNode(copyUses(oldUses, copy));
416 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
417 copy.addUnknownNodeBuilder(copy(un, copy, false));
423 public static UnknownSchemaNodeBuilderImpl copy(final UnknownSchemaNodeBuilder old, final Builder newParent,
424 final boolean updateQName) {
425 DataBean data = getdata(old, newParent, updateQName);
426 QName newQName = data.qname;
427 SchemaPath newSchemaPath = data.schemaPath;
429 UnknownSchemaNodeBuilderImpl c = new UnknownSchemaNodeBuilderImpl(newParent.getModuleName(),
430 newParent.getLine(), newQName, newSchemaPath);
432 c.setNodeType(old.getNodeType());
433 c.setNodeParameter(old.getNodeParameter());
434 c.setParent(newParent);
435 c.setDescription(old.getDescription());
436 c.setReference(old.getReference());
437 c.setStatus(old.getStatus());
438 c.setAddedByUses(old.isAddedByUses());
439 for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
440 c.addUnknownNodeBuilder(copy(un, c, updateQName));
442 c.setExtensionBuilder(old.getExtensionBuilder());
443 c.setExtensionDefinition(old.getExtensionDefinition());
448 private static DataBean getdata(final SchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
449 final SchemaPath newSchemaPath;
450 // this check avoid NPE because if old is IdentityrefTypeBuilder, old.getQNname() return null
451 final boolean identityrefTypeCheck = !(old instanceof IdentityrefTypeBuilder) && updateQName;
453 QName newQName = null;
454 if (newParent instanceof ModuleBuilder) {
455 ModuleBuilder parent = (ModuleBuilder) newParent;
456 if (identityrefTypeCheck) {
457 newQName = QName.create(parent.getQNameModule(), old.getQName().getLocalName());
459 newQName = old.getQName();
461 newSchemaPath = SchemaPath.create(true, newQName);
462 } else if (newParent instanceof AugmentationSchemaBuilder) {
463 AugmentationSchemaBuilder augment = (AugmentationSchemaBuilder) newParent;
464 ModuleBuilder parent = BuilderUtils.getParentModule(newParent);
465 if (identityrefTypeCheck) {
466 newQName = QName.create(parent.getQNameModule(), old.getQName().getLocalName());
468 newQName = old.getQName();
470 newSchemaPath = augment.getTargetPath().createChild(newQName);
471 } else if (newParent instanceof SchemaNodeBuilder) {
472 SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
473 QName parentQName = parent.getQName();
474 if (identityrefTypeCheck) {
475 newQName = QName.create(parentQName, old.getQName().getLocalName());
477 newQName = old.getQName();
479 newSchemaPath = parent.getPath().createChild(newQName);
481 newSchemaPath = SchemaPath.ROOT;
484 return new DataBean(newQName, newSchemaPath);
487 private static final class DataBean {
488 private final QName qname;
489 private final SchemaPath schemaPath;
491 private DataBean(final QName qname, final SchemaPath schemaPath) {
493 this.schemaPath = schemaPath;