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