src/uk/ac/vamsas/objects/core/VamsasDocument.java

   1 /*
   2  * This class was automatically generated with
   3  * <a href="http://www.castor.org">Castor 1.1</a>, using an XML
   4  * Schema.
   5  * $Id$
   6  */
   7
   8 package uk.ac.vamsas.objects.core;
   9
  10   //---------------------------------/
  11  //- Imported classes and packages -/
  12 //---------------------------------/
  13
  14 import org.exolab.castor.xml.Marshaller;
  15 import org.exolab.castor.xml.Unmarshaller;
  16
  17 /**
  18  * Class VamsasDocument.
  19  *
  20  * @version $Revision$ $Date$
  21  */
  22 public class VamsasDocument extends uk.ac.vamsas.client.Vobject
  23 implements java.io.Serializable
  24 {
  25
  26
  27       //--------------------------/
  28      //- Class/Member Variables -/
  29     //--------------------------/
  30
  31     /**
  32      * Vamsas Document Version Number
  33      */
  34     private java.lang.String _version;
  35
  36     /**
  37      * Field _lockFile.
  38      */
  39     private uk.ac.vamsas.objects.core.LockFile _lockFile;
  40
  41     /**
  42      * Field _provenance.
  43      */
  44     private uk.ac.vamsas.objects.core.Provenance _provenance;
  45
  46     /**
  47      * contains unassociated trees and a number of analysis sets
  48      *
  49      */
  50     private java.util.Vector _VAMSASList;
  51
  52     /**
  53      * Field _applicationDataList.
  54      */
  55     private java.util.Vector _applicationDataList;
  56
  57     /**
  58      * Field _attachmentList.
  59      */
  60     private java.util.Vector _attachmentList;
  61
  62
  63       //----------------/
  64      //- Constructors -/
  65     //----------------/
  66
  67     public VamsasDocument() {
  68         super();
  69         this._VAMSASList = new java.util.Vector();
  70         this._applicationDataList = new java.util.Vector();
  71         this._attachmentList = new java.util.Vector();
  72     }
  73
  74
  75       //-----------/
  76      //- Methods -/
  77     //-----------/
  78
  79     /**
  80      *
  81      *
  82      * @param vApplicationData
  83      * @throws java.lang.IndexOutOfBoundsException if the index
  84      * given is outside the bounds of the collection
  85      */
  86     public void addApplicationData(
  87             final uk.ac.vamsas.objects.core.ApplicationData vApplicationData)
  88     throws java.lang.IndexOutOfBoundsException {
  89         this._applicationDataList.addElement(vApplicationData);
  90     }
  91
  92     /**
  93      *
  94      *
  95      * @param index
  96      * @param vApplicationData
  97      * @throws java.lang.IndexOutOfBoundsException if the index
  98      * given is outside the bounds of the collection
  99      */
 100     public void addApplicationData(
 101             final int index,
 102             final uk.ac.vamsas.objects.core.ApplicationData vApplicationData)
 103     throws java.lang.IndexOutOfBoundsException {
 104         this._applicationDataList.add(index, vApplicationData);
 105     }
 106
 107     /**
 108      *
 109      *
 110      * @param vAttachment
 111      * @throws java.lang.IndexOutOfBoundsException if the index
 112      * given is outside the bounds of the collection
 113      */
 114     public void addAttachment(
 115             final uk.ac.vamsas.objects.core.Attachment vAttachment)
 116     throws java.lang.IndexOutOfBoundsException {
 117         this._attachmentList.addElement(vAttachment);
 118     }
 119
 120     /**
 121      *
 122      *
 123      * @param index
 124      * @param vAttachment
 125      * @throws java.lang.IndexOutOfBoundsException if the index
 126      * given is outside the bounds of the collection
 127      */
 128     public void addAttachment(
 129             final int index,
 130             final uk.ac.vamsas.objects.core.Attachment vAttachment)
 131     throws java.lang.IndexOutOfBoundsException {
 132         this._attachmentList.add(index, vAttachment);
 133     }
 134
 135     /**
 136      *
 137      *
 138      * @param vVAMSAS
 139      * @throws java.lang.IndexOutOfBoundsException if the index
 140      * given is outside the bounds of the collection
 141      */
 142     public void addVAMSAS(
 143             final uk.ac.vamsas.objects.core.VAMSAS vVAMSAS)
 144     throws java.lang.IndexOutOfBoundsException {
 145         this._VAMSASList.addElement(vVAMSAS);
 146     }
 147
 148     /**
 149      *
 150      *
 151      * @param index
 152      * @param vVAMSAS
 153      * @throws java.lang.IndexOutOfBoundsException if the index
 154      * given is outside the bounds of the collection
 155      */
 156     public void addVAMSAS(
 157             final int index,
 158             final uk.ac.vamsas.objects.core.VAMSAS vVAMSAS)
 159     throws java.lang.IndexOutOfBoundsException {
 160         this._VAMSASList.add(index, vVAMSAS);
 161     }
 162
 163     /**
 164      * Method enumerateApplicationData.
 165      *
 166      * @return an Enumeration over all
 167      * uk.ac.vamsas.objects.core.ApplicationData elements
 168      */
 169     public java.util.Enumeration enumerateApplicationData(
 170     ) {
 171         return this._applicationDataList.elements();
 172     }
 173
 174     /**
 175      * Method enumerateAttachment.
 176      *
 177      * @return an Enumeration over all
 178      * uk.ac.vamsas.objects.core.Attachment elements
 179      */
 180     public java.util.Enumeration enumerateAttachment(
 181     ) {
 182         return this._attachmentList.elements();
 183     }
 184
 185     /**
 186      * Method enumerateVAMSAS.
 187      *
 188      * @return an Enumeration over all
 189      * uk.ac.vamsas.objects.core.VAMSAS elements
 190      */
 191     public java.util.Enumeration enumerateVAMSAS(
 192     ) {
 193         return this._VAMSASList.elements();
 194     }
 195
 196     /**
 197      * Overrides the java.lang.Object.equals method.
 198      *
 199      * @param obj
 200      * @return true if the objects are equal.
 201      */
 202     public boolean equals(
 203             final java.lang.Object obj) {
 204         if ( this == obj )
 205             return true;
 206
 207         if (super.equals(obj)==false)
 208             return false;
 209
 210         if (obj instanceof VamsasDocument) {
 211
 212             VamsasDocument temp = (VamsasDocument)obj;
 213             if (this._version != null) {
 214                 if (temp._version == null) return false;
 215                 else if (!(this._version.equals(temp._version)))
 216                     return false;
 217             }
 218             else if (temp._version != null)
 219                 return false;
 220             if (this._lockFile != null) {
 221                 if (temp._lockFile == null) return false;
 222                 else if (!(this._lockFile.equals(temp._lockFile)))
 223                     return false;
 224             }
 225             else if (temp._lockFile != null)
 226                 return false;
 227             if (this._provenance != null) {
 228                 if (temp._provenance == null) return false;
 229                 else if (!(this._provenance.equals(temp._provenance)))
 230                     return false;
 231             }
 232             else if (temp._provenance != null)
 233                 return false;
 234             if (this._VAMSASList != null) {
 235                 if (temp._VAMSASList == null) return false;
 236                 else if (!(this._VAMSASList.equals(temp._VAMSASList)))
 237                     return false;
 238             }
 239             else if (temp._VAMSASList != null)
 240                 return false;
 241             if (this._applicationDataList != null) {
 242                 if (temp._applicationDataList == null) return false;
 243                 else if (!(this._applicationDataList.equals(temp._applicationDataList)))
 244                     return false;
 245             }
 246             else if (temp._applicationDataList != null)
 247                 return false;
 248             if (this._attachmentList != null) {
 249                 if (temp._attachmentList == null) return false;
 250                 else if (!(this._attachmentList.equals(temp._attachmentList)))
 251                     return false;
 252             }
 253             else if (temp._attachmentList != null)
 254                 return false;
 255             return true;
 256         }
 257         return false;
 258     }
 259
 260     /**
 261      * Method getApplicationData.
 262      *
 263      * @param index
 264      * @throws java.lang.IndexOutOfBoundsException if the index
 265      * given is outside the bounds of the collection
 266      * @return the value of the
 267      * uk.ac.vamsas.objects.core.ApplicationData at the given index
 268      */
 269     public uk.ac.vamsas.objects.core.ApplicationData getApplicationData(
 270             final int index)
 271     throws java.lang.IndexOutOfBoundsException {
 272         // check bounds for index
 273         if (index < 0 || index >= this._applicationDataList.size()) {
 274             throw new IndexOutOfBoundsException("getApplicationData: Index value '" + index + "' not in range [0.." + (this._applicationDataList.size() - 1) + "]");
 275         }
 276
 277         return (uk.ac.vamsas.objects.core.ApplicationData) _applicationDataList.get(index);
 278     }
 279
 280     /**
 281      * Method getApplicationData.Returns the contents of the
 282      * collection in an Array.  <p>Note:  Just in case the
 283      * collection contents are changing in another thread, we pass
 284      * a 0-length Array of the correct type into the API call.
 285      * This way we <i>know</i> that the Array returned is of
 286      * exactly the correct length.
 287      *
 288      * @return this collection as an Array
 289      */
 290     public uk.ac.vamsas.objects.core.ApplicationData[] getApplicationData(
 291     ) {
 292         uk.ac.vamsas.objects.core.ApplicationData[] array = new uk.ac.vamsas.objects.core.ApplicationData[0];
 293         return (uk.ac.vamsas.objects.core.ApplicationData[]) this._applicationDataList.toArray(array);
 294     }
 295
 296     /**
 297      * Method getApplicationDataAsReference.Returns a reference to
 298      * '_applicationDataList'. No type checking is performed on any
 299      * modifications to the Vector.
 300      *
 301      * @return a reference to the Vector backing this class
 302      */
 303     public java.util.Vector getApplicationDataAsReference(
 304     ) {
 305         return this._applicationDataList;
 306     }
 307
 308     /**
 309      * Method getApplicationDataCount.
 310      *
 311      * @return the size of this collection
 312      */
 313     public int getApplicationDataCount(
 314     ) {
 315         return this._applicationDataList.size();
 316     }
 317
 318     /**
 319      * Method getAttachment.
 320      *
 321      * @param index
 322      * @throws java.lang.IndexOutOfBoundsException if the index
 323      * given is outside the bounds of the collection
 324      * @return the value of the
 325      * uk.ac.vamsas.objects.core.Attachment at the given index
 326      */
 327     public uk.ac.vamsas.objects.core.Attachment getAttachment(
 328             final int index)
 329     throws java.lang.IndexOutOfBoundsException {
 330         // check bounds for index
 331         if (index < 0 || index >= this._attachmentList.size()) {
 332             throw new IndexOutOfBoundsException("getAttachment: Index value '" + index + "' not in range [0.." + (this._attachmentList.size() - 1) + "]");
 333         }
 334
 335         return (uk.ac.vamsas.objects.core.Attachment) _attachmentList.get(index);
 336     }
 337
 338     /**
 339      * Method getAttachment.Returns the contents of the collection
 340      * in an Array.  <p>Note:  Just in case the collection contents
 341      * are changing in another thread, we pass a 0-length Array of
 342      * the correct type into the API call.  This way we <i>know</i>
 343      * that the Array returned is of exactly the correct length.
 344      *
 345      * @return this collection as an Array
 346      */
 347     public uk.ac.vamsas.objects.core.Attachment[] getAttachment(
 348     ) {
 349         uk.ac.vamsas.objects.core.Attachment[] array = new uk.ac.vamsas.objects.core.Attachment[0];
 350         return (uk.ac.vamsas.objects.core.Attachment[]) this._attachmentList.toArray(array);
 351     }
 352
 353     /**
 354      * Method getAttachmentAsReference.Returns a reference to
 355      * '_attachmentList'. No type checking is performed on any
 356      * modifications to the Vector.
 357      *
 358      * @return a reference to the Vector backing this class
 359      */
 360     public java.util.Vector getAttachmentAsReference(
 361     ) {
 362         return this._attachmentList;
 363     }
 364
 365     /**
 366      * Method getAttachmentCount.
 367      *
 368      * @return the size of this collection
 369      */
 370     public int getAttachmentCount(
 371     ) {
 372         return this._attachmentList.size();
 373     }
 374
 375     /**
 376      * Returns the value of field 'lockFile'.
 377      *
 378      * @return the value of field 'LockFile'.
 379      */
 380     public uk.ac.vamsas.objects.core.LockFile getLockFile(
 381     ) {
 382         return this._lockFile;
 383     }
 384
 385     /**
 386      * Returns the value of field 'provenance'.
 387      *
 388      * @return the value of field 'Provenance'.
 389      */
 390     public uk.ac.vamsas.objects.core.Provenance getProvenance(
 391     ) {
 392         return this._provenance;
 393     }
 394
 395     /**
 396      * Method getVAMSAS.
 397      *
 398      * @param index
 399      * @throws java.lang.IndexOutOfBoundsException if the index
 400      * given is outside the bounds of the collection
 401      * @return the value of the uk.ac.vamsas.objects.core.VAMSAS at
 402      * the given index
 403      */
 404     public uk.ac.vamsas.objects.core.VAMSAS getVAMSAS(
 405             final int index)
 406     throws java.lang.IndexOutOfBoundsException {
 407         // check bounds for index
 408         if (index < 0 || index >= this._VAMSASList.size()) {
 409             throw new IndexOutOfBoundsException("getVAMSAS: Index value '" + index + "' not in range [0.." + (this._VAMSASList.size() - 1) + "]");
 410         }
 411
 412         return (uk.ac.vamsas.objects.core.VAMSAS) _VAMSASList.get(index);
 413     }
 414
 415     /**
 416      * Method getVAMSAS.Returns the contents of the collection in
 417      * an Array.  <p>Note:  Just in case the collection contents
 418      * are changing in another thread, we pass a 0-length Array of
 419      * the correct type into the API call.  This way we <i>know</i>
 420      * that the Array returned is of exactly the correct length.
 421      *
 422      * @return this collection as an Array
 423      */
 424     public uk.ac.vamsas.objects.core.VAMSAS[] getVAMSAS(
 425     ) {
 426         uk.ac.vamsas.objects.core.VAMSAS[] array = new uk.ac.vamsas.objects.core.VAMSAS[0];
 427         return (uk.ac.vamsas.objects.core.VAMSAS[]) this._VAMSASList.toArray(array);
 428     }
 429
 430     /**
 431      * Method getVAMSASAsReference.Returns a reference to
 432      * '_VAMSASList'. No type checking is performed on any
 433      * modifications to the Vector.
 434      *
 435      * @return a reference to the Vector backing this class
 436      */
 437     public java.util.Vector getVAMSASAsReference(
 438     ) {
 439         return this._VAMSASList;
 440     }
 441
 442     /**
 443      * Method getVAMSASCount.
 444      *
 445      * @return the size of this collection
 446      */
 447     public int getVAMSASCount(
 448     ) {
 449         return this._VAMSASList.size();
 450     }
 451
 452     /**
 453      * Returns the value of field 'version'. The field 'version'
 454      * has the following description: Vamsas Document Version
 455      * Number
 456      *
 457      * @return the value of field 'Version'.
 458      */
 459     public java.lang.String getVersion(
 460     ) {
 461         return this._version;
 462     }
 463
 464     /**
 465      * Overrides the java.lang.Object.hashCode method.
 466      * <p>
 467      * The following steps came from <b>Effective Java Programming
 468      * Language Guide</b> by Joshua Bloch, Chapter 3
 469      *
 470      * @return a hash code value for the object.
 471      */
 472     public int hashCode(
 473     ) {
 474         int result = super.hashCode();
 475
 476         long tmp;
 477         if (_version != null) {
 478            result = 37 * result + _version.hashCode();
 479         }
 480         if (_lockFile != null) {
 481            result = 37 * result + _lockFile.hashCode();
 482         }
 483         if (_provenance != null) {
 484            result = 37 * result + _provenance.hashCode();
 485         }
 486         if (_VAMSASList != null) {
 487            result = 37 * result + _VAMSASList.hashCode();
 488         }
 489         if (_applicationDataList != null) {
 490            result = 37 * result + _applicationDataList.hashCode();
 491         }
 492         if (_attachmentList != null) {
 493            result = 37 * result + _attachmentList.hashCode();
 494         }
 495
 496         return result;
 497     }
 498
 499     /**
 500      * Method isValid.
 501      *
 502      * @return true if this object is valid according to the schema
 503      */
 504     public boolean isValid(
 505     ) {
 506         try {
 507             validate();
 508         } catch (org.exolab.castor.xml.ValidationException vex) {
 509             return false;
 510         }
 511         return true;
 512     }
 513
 514     /**
 515      *
 516      *
 517      * @param out
 518      * @throws org.exolab.castor.xml.MarshalException if object is
 519      * null or if any SAXException is thrown during marshaling
 520      * @throws org.exolab.castor.xml.ValidationException if this
 521      * object is an invalid instance according to the schema
 522      */
 523     public void marshal(
 524             final java.io.Writer out)
 525     throws org.exolab.castor.xml.MarshalException, org.exolab.castor.xml.ValidationException {
 526         Marshaller.marshal(this, out);
 527     }
 528
 529     /**
 530      *
 531      *
 532      * @param handler
 533      * @throws java.io.IOException if an IOException occurs during
 534      * marshaling
 535      * @throws org.exolab.castor.xml.ValidationException if this
 536      * object is an invalid instance according to the schema
 537      * @throws org.exolab.castor.xml.MarshalException if object is
 538      * null or if any SAXException is thrown during marshaling
 539      */
 540     public void marshal(
 541             final org.xml.sax.ContentHandler handler)
 542     throws java.io.IOException, org.exolab.castor.xml.MarshalException, org.exolab.castor.xml.ValidationException {
 543         Marshaller.marshal(this, handler);
 544     }
 545
 546     /**
 547      */
 548     public void removeAllApplicationData(
 549     ) {
 550         this._applicationDataList.clear();
 551     }
 552
 553     /**
 554      */
 555     public void removeAllAttachment(
 556     ) {
 557         this._attachmentList.clear();
 558     }
 559
 560     /**
 561      */
 562     public void removeAllVAMSAS(
 563     ) {
 564         this._VAMSASList.clear();
 565     }
 566
 567     /**
 568      * Method removeApplicationData.
 569      *
 570      * @param vApplicationData
 571      * @return true if the object was removed from the collection.
 572      */
 573     public boolean removeApplicationData(
 574             final uk.ac.vamsas.objects.core.ApplicationData vApplicationData) {
 575         boolean removed = _applicationDataList.remove(vApplicationData);
 576         return removed;
 577     }
 578
 579     /**
 580      * Method removeApplicationDataAt.
 581      *
 582      * @param index
 583      * @return the element removed from the collection
 584      */
 585     public uk.ac.vamsas.objects.core.ApplicationData removeApplicationDataAt(
 586             final int index) {
 587         java.lang.Object obj = this._applicationDataList.remove(index);
 588         return (uk.ac.vamsas.objects.core.ApplicationData) obj;
 589     }
 590
 591     /**
 592      * Method removeAttachment.
 593      *
 594      * @param vAttachment
 595      * @return true if the object was removed from the collection.
 596      */
 597     public boolean removeAttachment(
 598             final uk.ac.vamsas.objects.core.Attachment vAttachment) {
 599         boolean removed = _attachmentList.remove(vAttachment);
 600         return removed;
 601     }
 602
 603     /**
 604      * Method removeAttachmentAt.
 605      *
 606      * @param index
 607      * @return the element removed from the collection
 608      */
 609     public uk.ac.vamsas.objects.core.Attachment removeAttachmentAt(
 610             final int index) {
 611         java.lang.Object obj = this._attachmentList.remove(index);
 612         return (uk.ac.vamsas.objects.core.Attachment) obj;
 613     }
 614
 615     /**
 616      * Method removeVAMSAS.
 617      *
 618      * @param vVAMSAS
 619      * @return true if the object was removed from the collection.
 620      */
 621     public boolean removeVAMSAS(
 622             final uk.ac.vamsas.objects.core.VAMSAS vVAMSAS) {
 623         boolean removed = _VAMSASList.remove(vVAMSAS);
 624         return removed;
 625     }
 626
 627     /**
 628      * Method removeVAMSASAt.
 629      *
 630      * @param index
 631      * @return the element removed from the collection
 632      */
 633     public uk.ac.vamsas.objects.core.VAMSAS removeVAMSASAt(
 634             final int index) {
 635         java.lang.Object obj = this._VAMSASList.remove(index);
 636         return (uk.ac.vamsas.objects.core.VAMSAS) obj;
 637     }
 638
 639     /**
 640      *
 641      *
 642      * @param index
 643      * @param vApplicationData
 644      * @throws java.lang.IndexOutOfBoundsException if the index
 645      * given is outside the bounds of the collection
 646      */
 647     public void setApplicationData(
 648             final int index,
 649             final uk.ac.vamsas.objects.core.ApplicationData vApplicationData)
 650     throws java.lang.IndexOutOfBoundsException {
 651         // check bounds for index
 652         if (index < 0 || index >= this._applicationDataList.size()) {
 653             throw new IndexOutOfBoundsException("setApplicationData: Index value '" + index + "' not in range [0.." + (this._applicationDataList.size() - 1) + "]");
 654         }
 655
 656         this._applicationDataList.set(index, vApplicationData);
 657     }
 658
 659     /**
 660      *
 661      *
 662      * @param vApplicationDataArray
 663      */
 664     public void setApplicationData(
 665             final uk.ac.vamsas.objects.core.ApplicationData[] vApplicationDataArray) {
 666         //-- copy array
 667         _applicationDataList.clear();
 668
 669         for (int i = 0; i < vApplicationDataArray.length; i++) {
 670                 this._applicationDataList.add(vApplicationDataArray[i]);
 671         }
 672     }
 673
 674     /**
 675      * Sets the value of '_applicationDataList' by copying the
 676      * given Vector. All elements will be checked for type safety.
 677      *
 678      * @param vApplicationDataList the Vector to copy.
 679      */
 680     public void setApplicationData(
 681             final java.util.Vector vApplicationDataList) {
 682         // copy vector
 683         this._applicationDataList.clear();
 684
 685         this._applicationDataList.addAll(vApplicationDataList);
 686     }
 687
 688     /**
 689      * Sets the value of '_applicationDataList' by setting it to
 690      * the given Vector. No type checking is performed.
 691      * @deprecated
 692      *
 693      * @param applicationDataVector the Vector to set.
 694      */
 695     public void setApplicationDataAsReference(
 696             final java.util.Vector applicationDataVector) {
 697         this._applicationDataList = applicationDataVector;
 698     }
 699
 700     /**
 701      *
 702      *
 703      * @param index
 704      * @param vAttachment
 705      * @throws java.lang.IndexOutOfBoundsException if the index
 706      * given is outside the bounds of the collection
 707      */
 708     public void setAttachment(
 709             final int index,
 710             final uk.ac.vamsas.objects.core.Attachment vAttachment)
 711     throws java.lang.IndexOutOfBoundsException {
 712         // check bounds for index
 713         if (index < 0 || index >= this._attachmentList.size()) {
 714             throw new IndexOutOfBoundsException("setAttachment: Index value '" + index + "' not in range [0.." + (this._attachmentList.size() - 1) + "]");
 715         }
 716
 717         this._attachmentList.set(index, vAttachment);
 718     }
 719
 720     /**
 721      *
 722      *
 723      * @param vAttachmentArray
 724      */
 725     public void setAttachment(
 726             final uk.ac.vamsas.objects.core.Attachment[] vAttachmentArray) {
 727         //-- copy array
 728         _attachmentList.clear();
 729
 730         for (int i = 0; i < vAttachmentArray.length; i++) {
 731                 this._attachmentList.add(vAttachmentArray[i]);
 732         }
 733     }
 734
 735     /**
 736      * Sets the value of '_attachmentList' by copying the given
 737      * Vector. All elements will be checked for type safety.
 738      *
 739      * @param vAttachmentList the Vector to copy.
 740      */
 741     public void setAttachment(
 742             final java.util.Vector vAttachmentList) {
 743         // copy vector
 744         this._attachmentList.clear();
 745
 746         this._attachmentList.addAll(vAttachmentList);
 747     }
 748
 749     /**
 750      * Sets the value of '_attachmentList' by setting it to the
 751      * given Vector. No type checking is performed.
 752      * @deprecated
 753      *
 754      * @param attachmentVector the Vector to set.
 755      */
 756     public void setAttachmentAsReference(
 757             final java.util.Vector attachmentVector) {
 758         this._attachmentList = attachmentVector;
 759     }
 760
 761     /**
 762      * Sets the value of field 'lockFile'.
 763      *
 764      * @param lockFile the value of field 'lockFile'.
 765      */
 766     public void setLockFile(
 767             final uk.ac.vamsas.objects.core.LockFile lockFile) {
 768         this._lockFile = lockFile;
 769     }
 770
 771     /**
 772      * Sets the value of field 'provenance'.
 773      *
 774      * @param provenance the value of field 'provenance'.
 775      */
 776     public void setProvenance(
 777             final uk.ac.vamsas.objects.core.Provenance provenance) {
 778         this._provenance = provenance;
 779     }
 780
 781     /**
 782      *
 783      *
 784      * @param index
 785      * @param vVAMSAS
 786      * @throws java.lang.IndexOutOfBoundsException if the index
 787      * given is outside the bounds of the collection
 788      */
 789     public void setVAMSAS(
 790             final int index,
 791             final uk.ac.vamsas.objects.core.VAMSAS vVAMSAS)
 792     throws java.lang.IndexOutOfBoundsException {
 793         // check bounds for index
 794         if (index < 0 || index >= this._VAMSASList.size()) {
 795             throw new IndexOutOfBoundsException("setVAMSAS: Index value '" + index + "' not in range [0.." + (this._VAMSASList.size() - 1) + "]");
 796         }
 797
 798         this._VAMSASList.set(index, vVAMSAS);
 799     }
 800
 801     /**
 802      *
 803      *
 804      * @param vVAMSASArray
 805      */
 806     public void setVAMSAS(
 807             final uk.ac.vamsas.objects.core.VAMSAS[] vVAMSASArray) {
 808         //-- copy array
 809         _VAMSASList.clear();
 810
 811         for (int i = 0; i < vVAMSASArray.length; i++) {
 812                 this._VAMSASList.add(vVAMSASArray[i]);
 813         }
 814     }
 815
 816     /**
 817      * Sets the value of '_VAMSASList' by copying the given Vector.
 818      * All elements will be checked for type safety.
 819      *
 820      * @param vVAMSASList the Vector to copy.
 821      */
 822     public void setVAMSAS(
 823             final java.util.Vector vVAMSASList) {
 824         // copy vector
 825         this._VAMSASList.clear();
 826
 827         this._VAMSASList.addAll(vVAMSASList);
 828     }
 829
 830     /**
 831      * Sets the value of '_VAMSASList' by setting it to the given
 832      * Vector. No type checking is performed.
 833      * @deprecated
 834      *
 835      * @param VAMSASVector the Vector to set.
 836      */
 837     public void setVAMSASAsReference(
 838             final java.util.Vector VAMSASVector) {
 839         this._VAMSASList = VAMSASVector;
 840     }
 841
 842     /**
 843      * Sets the value of field 'version'. The field 'version' has
 844      * the following description: Vamsas Document Version Number
 845      *
 846      * @param version the value of field 'version'.
 847      */
 848     public void setVersion(
 849             final java.lang.String version) {
 850         this._version = version;
 851     }
 852
 853     /**
 854      * Method unmarshal.
 855      *
 856      * @param reader
 857      * @throws org.exolab.castor.xml.MarshalException if object is
 858      * null or if any SAXException is thrown during marshaling
 859      * @throws org.exolab.castor.xml.ValidationException if this
 860      * object is an invalid instance according to the schema
 861      * @return the unmarshaled
 862      * uk.ac.vamsas.objects.core.VamsasDocument
 863      */
 864     public static uk.ac.vamsas.objects.core.VamsasDocument unmarshal(
 865             final java.io.Reader reader)
 866     throws org.exolab.castor.xml.MarshalException, org.exolab.castor.xml.ValidationException {
 867         return (uk.ac.vamsas.objects.core.VamsasDocument) Unmarshaller.unmarshal(uk.ac.vamsas.objects.core.VamsasDocument.class, reader);
 868     }
 869
 870     /**
 871      *
 872      *
 873      * @throws org.exolab.castor.xml.ValidationException if this
 874      * object is an invalid instance according to the schema
 875      */
 876     public void validate(
 877     )
 878     throws org.exolab.castor.xml.ValidationException {
 879         org.exolab.castor.xml.Validator validator = new org.exolab.castor.xml.Validator();
 880         validator.validate(this);
 881     }
 882
 883 }