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