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.HashSet;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.opendaylight.yangtools.yang.common.QName;
  17 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  18 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  19 import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
  20 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  21 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
  22 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  23 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.impl.AugmentationSchemaBuilderImpl;
  27 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
  28 import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
  29 import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
  30 import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
  31 import org.opendaylight.yangtools.yang.parser.builder.impl.GroupingBuilderImpl;
  32 import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
  33 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
  34 import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
  35 import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
  36 import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
  37 import org.opendaylight.yangtools.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
  38 import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
  39 import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
  40 import org.opendaylight.yangtools.yang.parser.builder.impl.UsesNodeBuilderImpl;
  41
  42 public class CopyUtils {
  43
  44     /**
  45      * Create copy of DataSchemaNodeBuilder with new parent. If updateQName is
  46      * true, qname of node will be corrected based on new parent.
  47      *
  48      * @param old
  49      * @param newParent
  50      * @param updateQName
  51      * @return
  52      */
  53     public static DataSchemaNodeBuilder copy(DataSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
  54         if (old instanceof AnyXmlBuilder) {
  55             return copy((AnyXmlBuilder) old, newParent, updateQName);
  56         } else if (old instanceof ChoiceBuilder) {
  57             return copy((ChoiceBuilder) old, newParent, updateQName);
  58         } else if (old instanceof ContainerSchemaNodeBuilder) {
  59             return copy((ContainerSchemaNodeBuilder) old, newParent, updateQName);
  60         } else if (old instanceof LeafSchemaNodeBuilder) {
  61             return copy((LeafSchemaNodeBuilder) old, newParent, updateQName);
  62         } else if (old instanceof LeafListSchemaNodeBuilder) {
  63             return copy((LeafListSchemaNodeBuilder) old, newParent, updateQName);
  64         } else if (old instanceof ListSchemaNodeBuilder) {
  65             return copy((ListSchemaNodeBuilder) old, newParent, updateQName);
  66         } else if (old instanceof ChoiceCaseBuilder) {
  67             return copy((ChoiceCaseBuilder) old, newParent, updateQName);
  68         } else {
  69             throw new YangParseException(old.getModuleName(), old.getLine(),
  70                     "Failed to copy node: Unknown type of DataSchemaNode: " + old);
  71         }
  72     }
  73
  74     private static AnyXmlBuilder copy(AnyXmlBuilder old, Builder newParent, boolean updateQName) {
  75         DataBean data = getdata(old, newParent, updateQName);
  76         QName newQName = data.qname;
  77         SchemaPath newSchemaPath = data.schemaPath;
  78
  79         AnyXmlBuilder c = new AnyXmlBuilder(newParent.getModuleName(), newParent.getLine(), newQName, newSchemaPath);
  80         copyConstraints(c.getConstraints(), old.getConstraints());
  81         c.setParent(newParent);
  82         c.setPath(newSchemaPath);
  83         c.setDescription(old.getDescription());
  84         c.setReference(old.getReference());
  85         c.setStatus(old.getStatus());
  86         c.setAugmenting(old.isAugmenting());
  87         c.setAddedByUses(old.isAddedByUses());
  88         c.setConfiguration(old.isConfiguration());
  89         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
  90             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
  91         }
  92
  93         return c;
  94     }
  95
  96     private static ChoiceBuilder copy(ChoiceBuilder old, Builder newParent, boolean updateQName) {
  97         DataBean data = getdata(old, newParent, updateQName);
  98         QName newQName = data.qname;
  99         SchemaPath newSchemaPath = data.schemaPath;
 100
 101         ChoiceBuilder c = new ChoiceBuilder(newParent.getModuleName(), newParent.getLine(), newQName);
 102         copyConstraints(c.getConstraints(), old.getConstraints());
 103         c.setParent(newParent);
 104         c.setPath(newSchemaPath);
 105         c.setDescription(old.getDescription());
 106         c.setReference(old.getReference());
 107         c.setStatus(old.getStatus());
 108         c.setAugmenting(old.isAugmenting());
 109         c.setAddedByUses(old.isAddedByUses());
 110         c.setConfiguration(old.isConfiguration());
 111         for (ChoiceCaseBuilder childNode : old.getCases()) {
 112             c.addCase(copy(childNode, c, updateQName));
 113         }
 114         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
 115             c.addAugmentation(copyAugment(augment, c));
 116         }
 117         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 118             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 119         }
 120
 121         return c;
 122     }
 123
 124     private static ChoiceCaseBuilder copy(ChoiceCaseBuilder old, Builder newParent, boolean updateQName) {
 125         DataBean data = getdata(old, newParent, updateQName);
 126         QName newQName = data.qname;
 127         SchemaPath newSchemaPath = data.schemaPath;
 128
 129         ChoiceCaseBuilder c = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName);
 130         copyConstraints(c.getConstraints(), old.getConstraints());
 131         c.setParent(newParent);
 132         c.setPath(newSchemaPath);
 133         c.setDescription(old.getDescription());
 134         c.setReference(old.getReference());
 135         c.setStatus(old.getStatus());
 136         c.setAugmenting(old.isAugmenting());
 137         c.getChildNodes().addAll(old.getChildNodes());
 138         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 139             c.addChildNode(copy(childNode, c, updateQName));
 140         }
 141         c.getGroupings().addAll(old.getGroupings());
 142         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 143             c.addGrouping(copy(grouping, c, updateQName));
 144         }
 145         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 146             c.addTypedef(copy(tdb, c, updateQName));
 147         }
 148         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
 149             c.addUsesNode(copyUses(oldUses, c));
 150         }
 151         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 152             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 153         }
 154
 155         return c;
 156     }
 157
 158     private static ContainerSchemaNodeBuilder copy(ContainerSchemaNodeBuilder old, Builder newParent,
 159             boolean updateQName) {
 160         DataBean data = getdata(old, newParent, updateQName);
 161         QName newQName = data.qname;
 162         SchemaPath newSchemaPath = data.schemaPath;
 163
 164         ContainerSchemaNodeBuilder c = new ContainerSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 165                 newQName, newSchemaPath);
 166         copyConstraints(c.getConstraints(), old.getConstraints());
 167         c.setParent(newParent);
 168         c.setPath(newSchemaPath);
 169         c.setDescription(old.getDescription());
 170         c.setReference(old.getReference());
 171         c.setStatus(old.getStatus());
 172         c.setPresence(old.isPresence());
 173         c.setAugmenting(old.isAugmenting());
 174         c.setAddedByUses(old.isAddedByUses());
 175         c.setConfiguration(old.isConfiguration());
 176         c.setChildNodes(old.getChildNodes());
 177         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 178             c.addChildNode(copy(childNode, c, updateQName));
 179         }
 180         c.getGroupings().addAll(old.getGroupings());
 181         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 182             c.addGrouping(copy(grouping, c, updateQName));
 183         }
 184         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 185             c.addTypedef(copy(tdb, c, updateQName));
 186         }
 187         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
 188             c.addUsesNode(copyUses(oldUses, c));
 189         }
 190         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
 191             c.addAugmentation(copyAugment(augment, c));
 192         }
 193         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 194             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 195         }
 196
 197         return c;
 198     }
 199
 200     private static LeafSchemaNodeBuilder copy(LeafSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
 201         DataBean data = getdata(old, newParent, updateQName);
 202         QName newQName = data.qname;
 203         SchemaPath newSchemaPath = data.schemaPath;
 204
 205         LeafSchemaNodeBuilder c = new LeafSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(), newQName,
 206                 newSchemaPath);
 207         copyConstraints(c.getConstraints(), old.getConstraints());
 208         c.setParent(newParent);
 209         c.setPath(newSchemaPath);
 210         c.setDescription(old.getDescription());
 211         c.setReference(old.getReference());
 212         c.setStatus(old.getStatus());
 213         c.setAugmenting(old.isAugmenting());
 214         c.setAddedByUses(old.isAddedByUses());
 215         c.setConfiguration(old.isConfiguration());
 216         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 217             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 218         }
 219
 220         if (old.getType() == null) {
 221             c.setTypedef(copy(old.getTypedef(), c, updateQName));
 222         } else {
 223             c.setType(old.getType());
 224         }
 225
 226         c.setDefaultStr(old.getDefaultStr());
 227         c.setUnits(old.getUnits());
 228
 229         return c;
 230     }
 231
 232     public static LeafListSchemaNodeBuilder copy(LeafListSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
 233         DataBean data = getdata(old, newParent, updateQName);
 234         QName newQName = data.qname;
 235         SchemaPath newSchemaPath = data.schemaPath;
 236
 237         LeafListSchemaNodeBuilder c = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 238                 newQName, newSchemaPath);
 239         copyConstraints(c.getConstraints(), old.getConstraints());
 240         c.setParent(newParent);
 241         c.setPath(newSchemaPath);
 242         c.setDescription(old.getDescription());
 243         c.setReference(old.getReference());
 244         c.setStatus(old.getStatus());
 245         c.setAugmenting(old.isAugmenting());
 246         c.setAddedByUses(old.isAddedByUses());
 247         c.setConfiguration(old.isConfiguration());
 248         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 249             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 250         }
 251
 252         if (old.getType() == null) {
 253             c.setTypedef(copy(old.getTypedef(), c, updateQName));
 254         } else {
 255             c.setType(old.getType());
 256         }
 257
 258         c.setUserOrdered(old.isUserOrdered());
 259
 260         return c;
 261     }
 262
 263     private static ListSchemaNodeBuilder copy(ListSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
 264         DataBean data = getdata(old, newParent, updateQName);
 265         QName newQName = data.qname;
 266         SchemaPath newSchemaPath = data.schemaPath;
 267
 268         ListSchemaNodeBuilder c = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(), newQName,
 269                 newSchemaPath);
 270         copyConstraints(c.getConstraints(), old.getConstraints());
 271         c.setParent(newParent);
 272         c.setPath(newSchemaPath);
 273         c.setDescription(old.getDescription());
 274         c.setReference(old.getReference());
 275         c.setStatus(old.getStatus());
 276         c.setAugmenting(old.isAugmenting());
 277         c.setAddedByUses(old.isAddedByUses());
 278         c.setConfiguration(old.isConfiguration());
 279         c.setChildNodes(old.getChildNodes());
 280         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 281             c.addChildNode(copy(childNode, c, updateQName));
 282         }
 283         c.getGroupings().addAll(old.getGroupings());
 284         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 285             c.addGrouping(copy(grouping, c, updateQName));
 286         }
 287         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 288             c.addTypedef(copy(tdb, c, updateQName));
 289         }
 290         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
 291             c.addUsesNode(copyUses(oldUses, c));
 292         }
 293         for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
 294             c.addAugmentation(copyAugment(augment, c));
 295         }
 296         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 297             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 298         }
 299
 300         c.setUserOrdered(old.isUserOrdered());
 301         c.setKeyDefinition(old.getKeyDefinition());
 302
 303         return c;
 304     }
 305
 306     static GroupingBuilder copy(GroupingBuilder old, Builder newParent, boolean updateQName) {
 307         DataBean data = getdata(old, newParent, updateQName);
 308         QName newQName = data.qname;
 309         SchemaPath newSchemaPath = data.schemaPath;
 310
 311         GroupingBuilderImpl c = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName);
 312         c.setParent(newParent);
 313         c.setPath(newSchemaPath);
 314         c.setDescription(old.getDescription());
 315         c.setReference(old.getReference());
 316         c.setStatus(old.getStatus());
 317         c.setAddedByUses(old.isAddedByUses());
 318         c.setChildNodes(old.getChildNodes());
 319         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 320             c.addChildNode(copy(childNode, c, updateQName));
 321         }
 322         c.getGroupings().addAll(old.getGroupings());
 323         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 324             c.addGrouping(copy(grouping, c, updateQName));
 325         }
 326         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 327             c.addTypedef(copy(tdb, c, updateQName));
 328         }
 329         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
 330             c.addUsesNode(copyUses(oldUses, c));
 331         }
 332         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 333             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 334         }
 335
 336         return c;
 337     }
 338
 339     static TypeDefinitionBuilder copy(TypeDefinitionBuilder old, Builder newParent, boolean updateQName) {
 340         DataBean data = getdata(old, newParent, updateQName);
 341         QName newQName = data.qname;
 342         SchemaPath newSchemaPath = data.schemaPath;
 343         TypeDefinitionBuilder type = null;
 344
 345         if (old instanceof UnionTypeBuilder) {
 346             type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
 347         } else if (old instanceof IdentityrefTypeBuilder) {
 348             type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
 349                     ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
 350         } else {
 351             type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName);
 352             type.setParent(newParent);
 353             type.setPath(newSchemaPath);
 354
 355             if (old.getType() == null) {
 356                 type.setTypedef(copy(old.getTypedef(), type, updateQName));
 357             } else {
 358                 type.setType(old.getType());
 359             }
 360
 361             for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 362                 type.addUnknownNodeBuilder((copy(un, type, updateQName)));
 363             }
 364
 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());
 375         }
 376
 377         return type;
 378     }
 379
 380     private static ConstraintsBuilder copyConstraints(ConstraintsBuilder newConstraints, ConstraintsBuilder old) {
 381         newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
 382         newConstraints.addWhenCondition(old.getWhenCondition());
 383         newConstraints.setMandatory(old.isMandatory());
 384         newConstraints.setMinElements(old.getMinElements());
 385         newConstraints.setMaxElements(old.getMaxElements());
 386         return newConstraints;
 387     }
 388
 389     static UsesNodeBuilder copyUses(UsesNodeBuilder old, Builder newParent) {
 390         UsesNodeBuilder u = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
 391                 old.getGroupingName());
 392         u.setParent(newParent);
 393         u.setGroupingPath(old.getGroupingPath());
 394         u.setAugmenting(old.isAugmenting());
 395         u.setAddedByUses(old.isAddedByUses());
 396         u.getAugmentations().addAll(old.getAugmentations());
 397         u.getRefineNodes().addAll(old.getRefineNodes());
 398         u.getRefines().addAll(old.getRefines());
 399         u.getFinalChildren().addAll(old.getFinalChildren());
 400         u.getFinalGroupings().addAll(old.getFinalGroupings());
 401         u.getFinalTypedefs().addAll(old.getFinalTypedefs());
 402         u.getFinalUnknownNodes().addAll(old.getFinalUnknownNodes());
 403
 404         Set<DataSchemaNodeBuilder> oldChildren = old.getTargetChildren();
 405         Set<DataSchemaNodeBuilder> newChildren = new HashSet<>();
 406         if (oldChildren != null) {
 407             for (DataSchemaNodeBuilder child : old.getTargetChildren()) {
 408                 newChildren.add(CopyUtils.copy(child, newParent, true));
 409             }
 410         }
 411         u.setTargetChildren(newChildren);
 412
 413         Set<TypeDefinitionBuilder> oldTypedefs = old.getTargetTypedefs();
 414         Set<TypeDefinitionBuilder> newTypedefs = new HashSet<>();
 415         if (oldTypedefs != null) {
 416             for (TypeDefinitionBuilder typedef : old.getTargetTypedefs()) {
 417                 newTypedefs.add(CopyUtils.copy(typedef, newParent, true));
 418             }
 419         }
 420         u.setTargetTypedefs(newTypedefs);
 421
 422         Set<GroupingBuilder> oldGroupings = old.getTargetGroupings();
 423         Set<GroupingBuilder> newGroupings = new HashSet<>();
 424         if (oldGroupings != null) {
 425             for (GroupingBuilder grouping : old.getTargetGroupings()) {
 426                 newGroupings.add(copy(grouping, newParent, true));
 427             }
 428         }
 429         u.setTargetGroupings(newGroupings);
 430
 431         List<UnknownSchemaNodeBuilder> oldUN = old.getTargetUnknownNodes();
 432         List<UnknownSchemaNodeBuilder> newUN = new ArrayList<>();
 433         if (oldUN != null) {
 434             for (UnknownSchemaNodeBuilder un : oldUN) {
 435                 newUN.add(copy(un, newParent, true));
 436             }
 437         }
 438         u.setTargetUnknownNodes(newUN);
 439
 440         for (UsesNodeBuilder uses : old.getTargetGroupingUses()) {
 441             u.getTargetGroupingUses().add(copyUses(uses, uses.getParent()));
 442         }
 443
 444         // add new uses to collection of uses in module
 445         ModuleBuilder module = ParserUtils.getParentModule(newParent);
 446         module.addUsesNode(u);
 447
 448         return u;
 449     }
 450
 451     private static AugmentationSchemaBuilder copyAugment(AugmentationSchemaBuilder old, Builder newParent) {
 452         AugmentationSchemaBuilderImpl a = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
 453                 newParent.getLine(), old.getTargetPathAsString());
 454         a.setParent(newParent);
 455
 456         a.setDescription(old.getDescription());
 457         a.setReference(old.getReference());
 458         a.setStatus(old.getStatus());
 459         a.addWhenCondition(old.getWhenCondition());
 460         a.setChildNodes(old.getChildNodes());
 461         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 462             a.addChildNode(copy(childNode, a, false));
 463         }
 464         for (UsesNodeBuilder oldUses : old.getUsesNodes()) {
 465             a.addUsesNode(copyUses(oldUses, a));
 466         }
 467         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 468             a.addUnknownNodeBuilder((copy(un, a, false)));
 469         }
 470
 471         return a;
 472     }
 473
 474     static UnknownSchemaNodeBuilder copy(UnknownSchemaNodeBuilder old, Builder newParent, boolean updateQName) {
 475         DataBean data = getdata(old, newParent, updateQName);
 476         QName newQName = data.qname;
 477         SchemaPath newSchemaPath = data.schemaPath;
 478
 479         UnknownSchemaNodeBuilder c = new UnknownSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 480                 newQName);
 481
 482         c.setParent(newParent);
 483         c.setPath(newSchemaPath);
 484         c.setDescription(old.getDescription());
 485         c.setReference(old.getReference());
 486         c.setStatus(old.getStatus());
 487         c.setAddedByUses(old.isAddedByUses());
 488         for (UnknownSchemaNodeBuilder un : old.getUnknownNodeBuilders()) {
 489             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 490         }
 491
 492         return c;
 493     }
 494
 495     private static DataBean getdata(SchemaNodeBuilder old, Builder newParent, boolean updateQName) {
 496         List<QName> newPath = null;
 497         QName newQName = null;
 498         if (newParent instanceof ModuleBuilder) {
 499             ModuleBuilder parent = (ModuleBuilder) newParent;
 500             if (updateQName) {
 501                 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
 502                         .getLocalName());
 503                 newPath = Collections.singletonList(newQName);
 504             } else {
 505                 newQName = old.getQName();
 506                 newPath = Collections.singletonList(newQName);
 507             }
 508         } else if (newParent instanceof AugmentationSchemaBuilder) {
 509             ModuleBuilder parent = ParserUtils.getParentModule(newParent);
 510             if (updateQName) {
 511                 newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
 512                         .getLocalName());
 513                 newPath = Collections.singletonList(newQName);
 514             } else {
 515                 newQName = old.getQName();
 516                 newPath = Collections.singletonList(newQName);
 517             }
 518
 519         } else if (newParent instanceof SchemaNodeBuilder) {
 520             SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
 521             QName parentQName = parent.getQName();
 522             if (updateQName) {
 523                 newQName = new QName(parentQName.getNamespace(), parentQName.getRevision(), parentQName.getPrefix(),
 524                         old.getQName().getLocalName());
 525                 newPath = new ArrayList<>(parent.getPath().getPath());
 526                 newPath.add(newQName);
 527             } else {
 528                 newQName = old.getQName();
 529                 newPath = new ArrayList<>(parent.getPath().getPath());
 530                 newPath.add(newQName);
 531             }
 532         }
 533
 534         SchemaPath newSchemaPath = new SchemaPath(newPath, true);
 535         return new DataBean(newQName, newSchemaPath);
 536     }
 537
 538     private static class DataBean {
 539         private QName qname;
 540         private SchemaPath schemaPath;
 541
 542         private DataBean(QName qname, SchemaPath schemaPath) {
 543             this.qname = qname;
 544             this.schemaPath = schemaPath;
 545         }
 546     }
 547
 548 }