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         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 133             copy.addUsesNode(copyUses(oldUses, copy));
 134         }
 135         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 136             copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
 137         }
 138
 139         return copy;
 140     }
 141
 142     private static ContainerSchemaNodeBuilder copy(final ContainerSchemaNodeBuilder old, final Builder newParent,
 143             final boolean updateQName) {
 144         DataBean data = getdata(old, newParent, updateQName);
 145         QName newQName = data.qname;
 146         SchemaPath newSchemaPath = data.schemaPath;
 147
 148         ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(newParent.getModuleName(),
 149                 newParent.getLine(), newQName, newSchemaPath);
 150         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 151         copyConstraints(copy.getConstraints(), old.getConstraints());
 152         copy.setParent(newParent);
 153         copy.setDescription(old.getDescription());
 154         copy.setReference(old.getReference());
 155         copy.setStatus(old.getStatus());
 156         copy.setPresence(old.isPresence());
 157         copy.setAugmenting(old.isAugmenting());
 158         copy.setAddedByUses(old.isAddedByUses());
 159         copy.setConfiguration(old.isConfiguration());
 160         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 161             copy.addChildNode(copy(childNode, copy, updateQName));
 162         }
 163         copy.getGroupings().addAll(old.getGroupings());
 164         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 165             copy.addGrouping(copy(grouping, copy, updateQName));
 166         }
 167         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 168             copy.addTypedef(copy(tdb, copy, updateQName));
 169         }
 170         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 171             copy.addUsesNode(copyUses(oldUses, copy));
 172         }
 173         for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
 174             copy.addAugmentation(copyAugment(augment, copy));
 175         }
 176         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 177             copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
 178         }
 179
 180         return copy;
 181     }
 182
 183     private static LeafSchemaNodeBuilder copy(final LeafSchemaNodeBuilder old, final Builder newParent,
 184             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         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 192         copyConstraints(copy.getConstraints(), old.getConstraints());
 193         copy.setParent(newParent);
 194         copy.setDescription(old.getDescription());
 195         copy.setReference(old.getReference());
 196         copy.setStatus(old.getStatus());
 197         copy.setAugmenting(old.isAugmenting());
 198         copy.setAddedByUses(old.isAddedByUses());
 199         copy.setConfiguration(old.isConfiguration());
 200         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 201             copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
 202         }
 203
 204         if (old.getType() == null) {
 205             copy.setTypedef(old.getTypedef());
 206         } else {
 207             copy.setType(old.getType());
 208         }
 209
 210         copy.setDefaultStr(old.getDefaultStr());
 211         copy.setUnits(old.getUnits());
 212
 213         return copy;
 214     }
 215
 216     private static LeafListSchemaNodeBuilder copy(final LeafListSchemaNodeBuilder old, final Builder newParent,
 217             final boolean updateQName) {
 218         DataBean data = getdata(old, newParent, updateQName);
 219         QName newQName = data.qname;
 220         SchemaPath newSchemaPath = data.schemaPath;
 221
 222         LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 223                 newQName, newSchemaPath);
 224         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 225         copyConstraints(copy.getConstraints(), old.getConstraints());
 226         copy.setParent(newParent);
 227         copy.setDescription(old.getDescription());
 228         copy.setReference(old.getReference());
 229         copy.setStatus(old.getStatus());
 230         copy.setAugmenting(old.isAugmenting());
 231         copy.setAddedByUses(old.isAddedByUses());
 232         copy.setConfiguration(old.isConfiguration());
 233         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 234             copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
 235         }
 236
 237         if (old.getType() == null) {
 238             copy.setTypedef(old.getTypedef());
 239         } else {
 240             copy.setType(old.getType());
 241         }
 242
 243         copy.setUserOrdered(old.isUserOrdered());
 244
 245         return copy;
 246     }
 247
 248     private static ListSchemaNodeBuilder copy(final ListSchemaNodeBuilder old, final Builder newParent,
 249             final boolean updateQName) {
 250         DataBean data = getdata(old, newParent, updateQName);
 251         QName newQName = data.qname;
 252         SchemaPath newSchemaPath = data.schemaPath;
 253
 254         ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
 255                 newQName, newSchemaPath);
 256         copy.setOriginal(old.getOriginal() == null ? old : old.getOriginal());
 257         copyConstraints(copy.getConstraints(), old.getConstraints());
 258         copy.setParent(newParent);
 259         copy.setDescription(old.getDescription());
 260         copy.setReference(old.getReference());
 261         copy.setStatus(old.getStatus());
 262         copy.setAugmenting(old.isAugmenting());
 263         copy.setAddedByUses(old.isAddedByUses());
 264         copy.setConfiguration(old.isConfiguration());
 265         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 266             copy.addChildNode(copy(childNode, copy, updateQName));
 267         }
 268         copy.getGroupings().addAll(old.getGroupings());
 269         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 270             copy.addGrouping(copy(grouping, copy, updateQName));
 271         }
 272         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 273             copy.addTypedef(copy(tdb, copy, updateQName));
 274         }
 275         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 276             copy.addUsesNode(copyUses(oldUses, copy));
 277         }
 278         for (AugmentationSchemaBuilder augment : old.getAugmentationBuilders()) {
 279             copy.addAugmentation(copyAugment(augment, copy));
 280         }
 281         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 282             copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
 283         }
 284
 285         copy.setUserOrdered(old.isUserOrdered());
 286         copy.setKeys(old.getKeys());
 287
 288         return copy;
 289     }
 290
 291     public static GroupingBuilder copy(final GroupingBuilder old, final Builder newParent, final boolean updateQName) {
 292         DataBean data = getdata(old, newParent, updateQName);
 293         QName newQName = data.qname;
 294         SchemaPath newSchemaPath = data.schemaPath;
 295
 296         GroupingBuilderImpl copy = new GroupingBuilderImpl(newParent.getModuleName(), newParent.getLine(), newQName,
 297                 newSchemaPath);
 298         copy.setParent(newParent);
 299         copy.setDescription(old.getDescription());
 300         copy.setReference(old.getReference());
 301         copy.setStatus(old.getStatus());
 302         copy.setAddedByUses(old.isAddedByUses());
 303         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 304             copy.addChildNode(copy(childNode, copy, updateQName));
 305         }
 306         copy.getGroupings().addAll(old.getGroupings());
 307         for (GroupingBuilder grouping : old.getGroupingBuilders()) {
 308             copy.addGrouping(copy(grouping, copy, updateQName));
 309         }
 310         for (TypeDefinitionBuilder tdb : old.getTypeDefinitionBuilders()) {
 311             copy.addTypedef(copy(tdb, copy, updateQName));
 312         }
 313         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 314             copy.addUsesNode(copyUses(oldUses, copy));
 315         }
 316         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 317             copy.addUnknownNodeBuilder(copy(un, copy, updateQName));
 318         }
 319
 320         return copy;
 321     }
 322
 323     public static TypeDefinitionBuilder copy(final TypeDefinitionBuilder old, final Builder newParent,
 324             final boolean updateQName) {
 325         DataBean data = getdata(old, newParent, updateQName);
 326         QName newQName = data.qname;
 327         SchemaPath newSchemaPath = data.schemaPath;
 328         TypeDefinitionBuilder type;
 329
 330         if (old instanceof UnionTypeBuilder) {
 331             UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
 332             type = new UnionTypeBuilder(newParent.getModuleName(), newParent.getLine());
 333             type.setParent(newParent);
 334             for (TypeDefinition<?> td : oldUnion.getTypes()) {
 335                 type.setType(td);
 336             }
 337             for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
 338                 type.setTypedef(copy(tdb, type, updateQName));
 339             }
 340         } else if (old instanceof IdentityrefTypeBuilder) {
 341             type = new IdentityrefTypeBuilder(newParent.getModuleName(), newParent.getLine(),
 342                     ((IdentityrefTypeBuilder) old).getBaseString(), newSchemaPath);
 343             type.setParent(newParent);
 344         } else {
 345             type = new TypeDefinitionBuilderImpl(old.getModuleName(), newParent.getLine(), newQName, old.getPath());
 346             type.setParent(newParent);
 347
 348             if (old.getType() == null) {
 349                 type.setTypedef(copy(old.getTypedef(), type, updateQName));
 350             } else {
 351                 type.setType(old.getType());
 352             }
 353
 354             for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 355                 type.addUnknownNodeBuilder(copy(un, type, updateQName));
 356             }
 357
 358             type.setRanges(old.getRanges());
 359             type.setLengths(old.getLengths());
 360             type.setPatterns(old.getPatterns());
 361             type.setFractionDigits(old.getFractionDigits());
 362             type.setDescription(old.getDescription());
 363             type.setReference(old.getReference());
 364             type.setStatus(old.getStatus());
 365             type.setUnits(old.getUnits());
 366             type.setDefaultValue(old.getDefaultValue());
 367             type.setAddedByUses(old.isAddedByUses());
 368         }
 369
 370         return type;
 371     }
 372
 373     private static ConstraintsBuilder copyConstraints(final ConstraintsBuilder newConstraints,
 374             final ConstraintsBuilder old) {
 375         newConstraints.getMustDefinitions().addAll(old.getMustDefinitions());
 376         newConstraints.addWhenCondition(old.getWhenCondition());
 377         newConstraints.setMandatory(old.isMandatory());
 378         newConstraints.setMinElements(old.getMinElements());
 379         newConstraints.setMaxElements(old.getMaxElements());
 380         return newConstraints;
 381     }
 382
 383     private static UsesNodeBuilder copyUses(final UsesNodeBuilder old, final Builder newParent) {
 384         UsesNodeBuilder copy = new UsesNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
 385                 old.getGroupingPath());
 386         copy.setParent(newParent);
 387         copy.setGroupingDefinition(old.getGroupingDefinition());
 388         copy.setGrouping(old.getGroupingBuilder());
 389         copy.setAddedByUses(old.isAddedByUses());
 390         copy.getAugmentations().addAll(old.getAugmentations());
 391         copy.getRefineNodes().addAll(old.getRefineNodes());
 392         copy.getRefines().addAll(old.getRefines());
 393         copy.setAugmenting(old.isAugmenting());
 394         return copy;
 395     }
 396
 397     private static AugmentationSchemaBuilder copyAugment(final AugmentationSchemaBuilder old, final Builder newParent) {
 398         AugmentationSchemaBuilderImpl copy = new AugmentationSchemaBuilderImpl(newParent.getModuleName(),
 399                 newParent.getLine(), old.getTargetPathAsString(), old.getTargetPath(), old.getOrder());
 400         copy.setParent(newParent);
 401         copy.setCopyOf(old);
 402         copy.setDescription(old.getDescription());
 403         copy.setReference(old.getReference());
 404         copy.setStatus(old.getStatus());
 405         copy.addWhenCondition(old.getWhenCondition());
 406         for (DataSchemaNodeBuilder childNode : old.getChildNodeBuilders()) {
 407             copy.addChildNode(copy(childNode, copy, false));
 408         }
 409         for (UsesNodeBuilder oldUses : old.getUsesNodeBuilders()) {
 410             copy.addUsesNode(copyUses(oldUses, copy));
 411         }
 412         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 413             copy.addUnknownNodeBuilder(copy(un, copy, false));
 414         }
 415
 416         return copy;
 417     }
 418
 419     public static UnknownSchemaNodeBuilderImpl copy(final UnknownSchemaNodeBuilder old, final Builder newParent,
 420             final boolean updateQName) {
 421         DataBean data = getdata(old, newParent, updateQName);
 422         QName newQName = data.qname;
 423         SchemaPath newSchemaPath = data.schemaPath;
 424
 425         UnknownSchemaNodeBuilderImpl c = new UnknownSchemaNodeBuilderImpl(newParent.getModuleName(),
 426                 newParent.getLine(), newQName, newSchemaPath);
 427
 428         c.setNodeType(old.getNodeType());
 429         c.setNodeParameter(old.getNodeParameter());
 430         c.setParent(newParent);
 431         c.setDescription(old.getDescription());
 432         c.setReference(old.getReference());
 433         c.setStatus(old.getStatus());
 434         c.setAddedByUses(old.isAddedByUses());
 435         for (UnknownSchemaNodeBuilder un : old.getUnknownNodes()) {
 436             c.addUnknownNodeBuilder(copy(un, c, updateQName));
 437         }
 438         c.setExtensionBuilder(old.getExtensionBuilder());
 439         c.setExtensionDefinition(old.getExtensionDefinition());
 440
 441         return c;
 442     }
 443
 444     private static DataBean getdata(final SchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
 445         final SchemaPath newSchemaPath;
 446         // this check avoid NPE because if old is IdentityrefTypeBuilder, old.getQNname() return null
 447         final boolean identityrefTypeCheck = old instanceof IdentityrefTypeBuilder ? false : updateQName;
 448
 449         QName newQName = null;
 450         if (newParent instanceof ModuleBuilder) {
 451             ModuleBuilder parent = (ModuleBuilder) newParent;
 452             if (identityrefTypeCheck) {
 453                 newQName = QName.create(parent.getQNameModule(), old.getQName().getLocalName());
 454             } else {
 455                 newQName = old.getQName();
 456             }
 457             newSchemaPath = SchemaPath.create(true, newQName);
 458         } else if (newParent instanceof AugmentationSchemaBuilder) {
 459             AugmentationSchemaBuilder augment = (AugmentationSchemaBuilder) newParent;
 460             ModuleBuilder parent = BuilderUtils.getParentModule(newParent);
 461             if (identityrefTypeCheck) {
 462                 newQName = QName.create(parent.getQNameModule(), old.getQName().getLocalName());
 463             } else {
 464                 newQName = old.getQName();
 465             }
 466             newSchemaPath = augment.getTargetPath().createChild(newQName);
 467         } else if (newParent instanceof SchemaNodeBuilder) {
 468             SchemaNodeBuilder parent = (SchemaNodeBuilder) newParent;
 469             QName parentQName = parent.getQName();
 470             if (identityrefTypeCheck) {
 471                 newQName = QName.create(parentQName, old.getQName().getLocalName());
 472             } else {
 473                 newQName = old.getQName();
 474             }
 475             newSchemaPath = parent.getPath().createChild(newQName);
 476         } else {
 477             newSchemaPath = SchemaPath.ROOT;
 478         }
 479
 480         return new DataBean(newQName, newSchemaPath);
 481     }
 482
 483     private static final class DataBean {
 484         private final QName qname;
 485         private final SchemaPath schemaPath;
 486
 487         private DataBean(final QName qname, final SchemaPath schemaPath) {
 488             this.qname = qname;
 489             this.schemaPath = schemaPath;
 490         }
 491     }
 492
 493 }