yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/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.builder.impl;
   9
  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;
  23
  24 public final class CopyUtils {
  25
  26     private CopyUtils() {
  27     }
  28
  29     /**
  30      * Create copy of DataSchemaNodeBuilder with new parent. If updateQName is
  31      * true, qname of node will be corrected based on new parent.
  32      *
  33      * @param old
  34      *            builder to copy
  35      * @param newParent
  36      *            new parent
  37      * @param updateQName
  38      *            flag to indicate if qname should be updated based on new
  39      *            parent location
  40      * @return copy of given builder
  41      */
  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);
  58         } else {
  59             throw new YangParseException(old.getModuleName(), old.getLine(),
  60                     "Failed to copy node: Unknown type of DataSchemaNode: " + old);
  61         }
  62     }
  63
  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;
  68
  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)));
  81         }
  82
  83         return copy;
  84     }
  85
  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;
  90
  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));
 103         }
 104         for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
 105             copy.addAugmentation(copyAugment(augment, copy));
 106         }
 107         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 108             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
 109         }
 110
 111         return copy;
 112     }
 113
 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;
 119
 120         ChoiceCaseBuilder copy = new ChoiceCaseBuilder(newParent.getModuleName(), newParent.getLine(), newQName,
 121                 newSchemaPath);
 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));
 131         }
 132         copy.getGroupings().addAll(old.getGroupings());
 133         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 134             copy.addGrouping(copy(grouping, copy, updateQName));
 135         }
 136         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 137             copy.addTypedef(copy(tdb, copy, updateQName));
 138         }
 139         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 140             copy.addUsesNode(copyUses(oldUses, copy));
 141         }
 142         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 143             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
 144         }
 145
 146         return copy;
 147     }
 148
 149     private static ContainerSchemaNodeBuilder copy(final ContainerSchemaNodeBuilder old, final Builder newParent,
 150             final boolean updateQName) {
 151         DataBean data = getdata(old, newParent, updateQName);
 152         QName newQName = data.qname;
 153         SchemaPath newSchemaPath = data.schemaPath;
 154
 155         ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(newParent.getModuleName(),
 156                 newParent.getLine(), newQName, newSchemaPath);
 157         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 158         copyConstraints(copy.getConstraints(), old.getConstraints());
 159         copy.setParent(newParent);
 160         copy.setDescription(old.getDescription());
 161         copy.setReference(old.getReference());
 162         copy.setStatus(old.getStatus());
 163         copy.setPresence(old.isPresence());
 164         copy.setAugmenting(old.isAugmenting());
 165         copy.setAddedByUses(old.isAddedByUses());
 166         copy.setConfiguration(old.isConfiguration());
 167         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 168             copy.addChildNode(copy(childNode, copy, updateQName));
 169         }
 170         copy.getGroupings().addAll(old.getGroupings());
 171         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 172             copy.addGrouping(copy(grouping, copy, updateQName));
 173         }
 174         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 175             copy.addTypedef(copy(tdb, copy, updateQName));
 176         }
 177         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 178             copy.addUsesNode(copyUses(oldUses, copy));
 179         }
 180         for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
 181             copy.addAugmentation(copyAugment(augment, copy));
 182         }
 183         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 184             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
 185         }
 186
 187         return copy;
 188     }
 189
 190     private static LeafSchemaNodeBuilder copy(final LeafSchemaNodeBuilder old, final Builder newParent,
 191             final boolean updateQName) {
 192         DataBean data = getdata(old, newParent, updateQName);
 193         QName newQName = data.qname;
 194         SchemaPath newSchemaPath = data.schemaPath;
 195
 196         LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 197                 newQName, newSchemaPath);
 198         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 199         copyConstraints(copy.getConstraints(), old.getConstraints());
 200         copy.setParent(newParent);
 201         copy.setDescription(old.getDescription());
 202         copy.setReference(old.getReference());
 203         copy.setStatus(old.getStatus());
 204         copy.setAugmenting(old.isAugmenting());
 205         copy.setAddedByUses(old.isAddedByUses());
 206         copy.setConfiguration(old.isConfiguration());
 207         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 208             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
 209         }
 210
 211         if (old.getType() == null) {
 212             copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
 213         } else {
 214             copy.setType(old.getType());
 215         }
 216
 217         copy.setDefaultStr(old.getDefaultStr());
 218         copy.setUnits(old.getUnits());
 219
 220         return copy;
 221     }
 222
 223     private static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent,
 224             final boolean updateQName) {
 225         DataBean data = getdata(old, newParent, updateQName);
 226         QName newQName = data.qname;
 227         SchemaPath newSchemaPath = data.schemaPath;
 228
 229         LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 230                 newQName, newSchemaPath);
 231         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 232         copyConstraints(copy.getConstraints(), old.getConstraints());
 233         copy.setParent(newParent);
 234         copy.setDescription(old.getDescription());
 235         copy.setReference(old.getReference());
 236         copy.setStatus(old.getStatus());
 237         copy.setAugmenting(old.isAugmenting());
 238         copy.setAddedByUses(old.isAddedByUses());
 239         copy.setConfiguration(old.isConfiguration());
 240         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 241             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
 242         }
 243
 244         if (old.getType() == null) {
 245             copy.setTypedef(copy(old.getTypedef(), copy, updateQName));
 246         } else {
 247             copy.setType(old.getType());
 248         }
 249
 250         copy.setUserOrdered(old.isUserOrdered());
 251
 252         return copy;
 253     }
 254
 255     private static ListSchemaNodeBuilder copy(final ListSchemaNodeBuilder old, final Builder newParent,
 256             final boolean updateQName) {
 257         DataBean data = getdata(old, newParent, updateQName);
 258         QName newQName = data.qname;
 259         SchemaPath newSchemaPath = data.schemaPath;
 260
 261         ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 262                 newQName, newSchemaPath);
 263         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 264         copyConstraints(copy.getConstraints(), old.getConstraints());
 265         copy.setParent(newParent);
 266         copy.setDescription(old.getDescription());
 267         copy.setReference(old.getReference());
 268         copy.setStatus(old.getStatus());
 269         copy.setAugmenting(old.isAugmenting());
 270         copy.setAddedByUses(old.isAddedByUses());
 271         copy.setConfiguration(old.isConfiguration());
 272         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 273             copy.addChildNode(copy(childNode, copy, updateQName));
 274         }
 275         copy.getGroupings().addAll(old.getGroupings());
 276         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 277             copy.addGrouping(copy(grouping, copy, updateQName));
 278         }
 279         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 280             copy.addTypedef(copy(tdb, copy, updateQName));
 281         }
 282         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 283             copy.addUsesNode(copyUses(oldUses, copy));
 284         }
 285         for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
 286             copy.addAugmentation(copyAugment(augment, copy));
 287         }
 288         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 289             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
 290         }
 291
 292         copy.setUserOrdered(old.isUserOrdered());
 293         copy.setKeys(old.getKeys());
 294
 295         return copy;
 296     }
 297
 298     public static GroupingBuilder copy(final GroupingBuilder old, final Builder newParent, final boolean updateQName) {
 299         DataBean data = getdata(old, newParent, updateQName);
 300         QName newQName = data.qname;
 301         SchemaPath newSchemaPath = data.schemaPath;
 302
 303         GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName,
 304                 newSchemaPath);
 305         copy.setParent(newParent);
 306         copy.setDescription(old.getDescription());
 307         copy.setReference(old.getReference());
 308         copy.setStatus(old.getStatus());
 309         copy.setAddedByUses(old.isAddedByUses());
 310         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 311             copy.addChildNode(copy(childNode, copy, updateQName));
 312         }
 313         copy.getGroupings().addAll(old.getGroupings());
 314         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 315             copy.addGrouping(copy(grouping, copy, updateQName));
 316         }
 317         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 318             copy.addTypedef(copy(tdb, copy, updateQName));
 319         }
 320         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 321             copy.addUsesNode(copyUses(oldUses, copy));
 322         }
 323         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 324             copy.addUnknownNodeBuilder((copy(un, copy, updateQName)));
 325         }
 326
 327         return copy;
 328     }
 329
 330     public static TypeDefinitionBuilder copy(final TypeDefinitionBuilder old, final Builder newParent,
 331             final boolean updateQName) {
 332         DataBean data = getdata(old, newParent, updateQName);
 333         QName newQName = data.qname;
 334         SchemaPath newSchemaPath = data.schemaPath;
 335         TypeDefinitionBuilder type;
 336
 337         if (old instanceof UnionTypeBuilder) {
 338             UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
 339             type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
 340             type.setParent(newParent);
 341             for (TypeDefinition<?> td : oldUnion.getTypes()) {
 342                 type.setType(td);
 343             }
 344             for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
 345                 type.setTypedef(copy(tdb, type, updateQName));
 346             }
 347         } else if (old instanceof IdentityrefTypeBuilder) {
 348             type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
 349                     ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
 350             type.setParent(newParent);
 351         } else {
 352             type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName, old.getPath());
 353             type.setParent(newParent);
 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.getUnknownNodes()) {
 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(final ConstraintsBuilder newConstraints,
 381             final ConstraintsBuilder old) {
 382         newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
 383         newConstraints.addWhenCondition(old.getWhenCondition());
 384         newConstraints.setMandatory(old.isMandatory());
 385         newConstraints.setMinElements(old.getMinElements());
 386         newConstraints.setMaxElements(old.getMaxElements());
 387         return newConstraints;
 388     }
 389
 390     private static UsesNodeBuilder copyUses(final UsesNodeBuilder old, final Builder newParent) {
 391         UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
 392                 old.getGroupingPathAsString());
 393         copy.setParent(newParent);
 394         copy.setGroupingDefinition(old.getGroupingDefinition());
 395         copy.setGrouping(old.getGroupingBuilder());
 396         copy.setAddedByUses(old.isAddedByUses());
 397         copy.getAugmentations().addAll(old.getAugmentations());
 398         copy.getRefineNodes().addAll(old.getRefineNodes());
 399         copy.getRefines().addAll(old.getRefines());
 400         copy.setAugmenting(old.isAugmenting());
 401         return copy;
 402     }
 403
 404     private static AugmentationSchemaBuilder copyAugment(final AugmentationSchemaBuilder old, final Builder newParent) {
 405         AugmentationSchemaBuilderImpl copy = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
 406                 newParent.getLine(), old.getTargetPathAsString(), old.getOrder());
 407         copy.setParent(newParent);
 408         copy.setCopyOf(old);
 409         copy.setDescription(old.getDescription());
 410         copy.setReference(old.getReference());
 411         copy.setStatus(old.getStatus());
 412         copy.addWhenCondition(old.getWhenCondition());
 413         copy.setTargetNodeSchemaPath(old.getTargetNodeSchemaPath());
 414         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 415             copy.addChildNode(copy(childNode, copy, false));
 416         }
 417         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 418             copy.addUsesNode(copyUses(oldUses, copy));
 419         }
 420         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 421             copy.addUnknownNodeBuilder((copy(un, copy, false)));
 422         }
 423
 424         return copy;
 425     }
 426
 427     public static UnknownSchemaNodeBuilderImpl copy(final UnknownSchemaNodeBuilder old, final Builder newParent,
 428             final boolean updateQName) {
 429         DataBean data = getdata(old, newParent, updateQName);
 430         QName newQName = data.qname;
 431         SchemaPath newSchemaPath = data.schemaPath;
 432
 433         UnknownSchemaNodeBuilderImpl c = new UnknownSchemaNodeBuilderImpl(newParent.getModuleName(),
 434                 newParent.getLine(), newQName, newSchemaPath);
 435
 436         c.setNodeType(old.getNodeType());
 437         c.setNodeParameter(old.getNodeParameter());
 438         c.setParent(newParent);
 439         c.setDescription(old.getDescription());
 440         c.setReference(old.getReference());
 441         c.setStatus(old.getStatus());
 442         c.setAddedByUses(old.isAddedByUses());
 443         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 444             c.addUnknownNodeBuilder((copy(un, c, updateQName)));
 445         }
 446         c.setExtensionBuilder(old.getExtensionBuilder());
 447         c.setExtensionDefinition(old.getExtensionDefinition());
 448
 449         return c;
 450     }
 451
 452     private static DataBean getdata(final SchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
 453         final SchemaPath newSchemaPath;
 454         QName newQName = null;
 455         if (newParent instanceof ModuleBuilder) {
 456             ModuleBuilder parent = (ModuleBuilder) newParent;
 457             if (updateQName) {
 458                 newQName = QName.create(parent.getQNameModule(), parent.getPrefix(), old.getQName()
 459                         .getLocalName());
 460             } else {
 461                 newQName = old.getQName();
 462             }
 463             newSchemaPath = SchemaPath.create(true, newQName);
 464         } else if (newParent instanceof AugmentationSchemaBuilder) {
 465             AugmentationSchemaBuilder augment = (AugmentationSchemaBuilder) newParent;
 466             ModuleBuilder parent = BuilderUtils.getParentModule(newParent);
 467             if (updateQName) {
 468                 newQName = QName.create(parent.getQNameModule(), parent.getPrefix(), old.getQName()
 469                         .getLocalName());
 470             } else {
 471                 newQName = old.getQName();
 472             }
 473             newSchemaPath = augment.getTargetNodeSchemaPath().createChild(newQName);
 474         } else if (newParent instanceof SchemaNodeBuilder) {
 475             SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
 476             QName parentQName = parent.getQName();
 477             if (updateQName) {
 478                 newQName = QName.create(parentQName, old.getQName().getLocalName());
 479             } else {
 480                 newQName = old.getQName();
 481             }
 482             newSchemaPath = parent.getPath().createChild(newQName);
 483         } else {
 484             newSchemaPath = SchemaPath.ROOT;
 485         }
 486
 487         return new DataBean(newQName, newSchemaPath);
 488     }
 489
 490     private static final class DataBean {
 491         private final QName qname;
 492         private final SchemaPath schemaPath;
 493
 494         private DataBean(final QName qname, final SchemaPath schemaPath) {
 495             this.qname = qname;
 496             this.schemaPath = schemaPath;
 497         }
 498     }
 499
 500 }