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