src/jalview/binding/VAMSAS.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.0b1)
   3  * Copyright (C) 2014 The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  10  *
  11  * Jalview is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty
  13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14  * PURPOSE.  See the GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  17  * The Jalview Authors are detailed in the 'AUTHORS' file.
  18  */
  19 package jalview.binding;
  20
  21 //---------------------------------/
  22 //- Imported classes and packages -/
  23 //---------------------------------/
  24
  25 import org.exolab.castor.xml.Marshaller;
  26 import org.exolab.castor.xml.Unmarshaller;
  27
  28 /**
  29  * Class VAMSAS.
  30  *
  31  * @version $Revision$ $Date$
  32  */
  33 public class VAMSAS implements java.io.Serializable
  34 {
  35
  36   // --------------------------/
  37   // - Class/Member Variables -/
  38   // --------------------------/
  39
  40   /**
  41    * Field _alignmentList.
  42    */
  43   private java.util.Vector _alignmentList;
  44
  45   /**
  46    * Field _treeList.
  47    */
  48   private java.util.Vector _treeList;
  49
  50   /**
  51    * Field _sequenceSetList.
  52    */
  53   private java.util.Vector _sequenceSetList;
  54
  55   // ----------------/
  56   // - Constructors -/
  57   // ----------------/
  58
  59   public VAMSAS()
  60   {
  61     super();
  62     this._alignmentList = new java.util.Vector();
  63     this._treeList = new java.util.Vector();
  64     this._sequenceSetList = new java.util.Vector();
  65   }
  66
  67   // -----------/
  68   // - Methods -/
  69   // -----------/
  70
  71   /**
  72    *
  73    *
  74    * @param vAlignment
  75    * @throws java.lang.IndexOutOfBoundsException
  76    *           if the index given is outside the bounds of the collection
  77    */
  78   public void addAlignment(final Alignment vAlignment)
  79           throws java.lang.IndexOutOfBoundsException
  80   {
  81     this._alignmentList.addElement(vAlignment);
  82   }
  83
  84   /**
  85    *
  86    *
  87    * @param index
  88    * @param vAlignment
  89    * @throws java.lang.IndexOutOfBoundsException
  90    *           if the index given is outside the bounds of the collection
  91    */
  92   public void addAlignment(final int index, final Alignment vAlignment)
  93           throws java.lang.IndexOutOfBoundsException
  94   {
  95     this._alignmentList.add(index, vAlignment);
  96   }
  97
  98   /**
  99    *
 100    *
 101    * @param vSequenceSet
 102    * @throws java.lang.IndexOutOfBoundsException
 103    *           if the index given is outside the bounds of the collection
 104    */
 105   public void addSequenceSet(final SequenceSet vSequenceSet)
 106           throws java.lang.IndexOutOfBoundsException
 107   {
 108     this._sequenceSetList.addElement(vSequenceSet);
 109   }
 110
 111   /**
 112    *
 113    *
 114    * @param index
 115    * @param vSequenceSet
 116    * @throws java.lang.IndexOutOfBoundsException
 117    *           if the index given is outside the bounds of the collection
 118    */
 119   public void addSequenceSet(final int index, final SequenceSet vSequenceSet)
 120           throws java.lang.IndexOutOfBoundsException
 121   {
 122     this._sequenceSetList.add(index, vSequenceSet);
 123   }
 124
 125   /**
 126    *
 127    *
 128    * @param vTree
 129    * @throws java.lang.IndexOutOfBoundsException
 130    *           if the index given is outside the bounds of the collection
 131    */
 132   public void addTree(final java.lang.String vTree)
 133           throws java.lang.IndexOutOfBoundsException
 134   {
 135     this._treeList.addElement(vTree);
 136   }
 137
 138   /**
 139    *
 140    *
 141    * @param index
 142    * @param vTree
 143    * @throws java.lang.IndexOutOfBoundsException
 144    *           if the index given is outside the bounds of the collection
 145    */
 146   public void addTree(final int index, final java.lang.String vTree)
 147           throws java.lang.IndexOutOfBoundsException
 148   {
 149     this._treeList.add(index, vTree);
 150   }
 151
 152   /**
 153    * Method enumerateAlignment.
 154    *
 155    * @return an Enumeration over all Alignment elements
 156    */
 157   public java.util.Enumeration enumerateAlignment()
 158   {
 159     return this._alignmentList.elements();
 160   }
 161
 162   /**
 163    * Method enumerateSequenceSet.
 164    *
 165    * @return an Enumeration over all SequenceSet elements
 166    */
 167   public java.util.Enumeration enumerateSequenceSet()
 168   {
 169     return this._sequenceSetList.elements();
 170   }
 171
 172   /**
 173    * Method enumerateTree.
 174    *
 175    * @return an Enumeration over all java.lang.String elements
 176    */
 177   public java.util.Enumeration enumerateTree()
 178   {
 179     return this._treeList.elements();
 180   }
 181
 182   /**
 183    * Method getAlignment.
 184    *
 185    * @param index
 186    * @throws java.lang.IndexOutOfBoundsException
 187    *           if the index given is outside the bounds of the collection
 188    * @return the value of the Alignment at the given index
 189    */
 190   public Alignment getAlignment(final int index)
 191           throws java.lang.IndexOutOfBoundsException
 192   {
 193     // check bounds for index
 194     if (index < 0 || index >= this._alignmentList.size())
 195     {
 196       throw new IndexOutOfBoundsException("getAlignment: Index value '"
 197               + index + "' not in range [0.."
 198               + (this._alignmentList.size() - 1) + "]");
 199     }
 200
 201     return (Alignment) _alignmentList.get(index);
 202   }
 203
 204   /**
 205    * Method getAlignment.Returns the contents of the collection in an Array.
 206    * <p>
 207    * Note: Just in case the collection contents are changing in another thread,
 208    * we pass a 0-length Array of the correct type into the API call. This way we
 209    * <i>know</i> that the Array returned is of exactly the correct length.
 210    *
 211    * @return this collection as an Array
 212    */
 213   public Alignment[] getAlignment()
 214   {
 215     Alignment[] array = new Alignment[0];
 216     return (Alignment[]) this._alignmentList.toArray(array);
 217   }
 218
 219   /**
 220    * Method getAlignmentCount.
 221    *
 222    * @return the size of this collection
 223    */
 224   public int getAlignmentCount()
 225   {
 226     return this._alignmentList.size();
 227   }
 228
 229   /**
 230    * Method getSequenceSet.
 231    *
 232    * @param index
 233    * @throws java.lang.IndexOutOfBoundsException
 234    *           if the index given is outside the bounds of the collection
 235    * @return the value of the SequenceSet at the given index
 236    */
 237   public SequenceSet getSequenceSet(final int index)
 238           throws java.lang.IndexOutOfBoundsException
 239   {
 240     // check bounds for index
 241     if (index < 0 || index >= this._sequenceSetList.size())
 242     {
 243       throw new IndexOutOfBoundsException("getSequenceSet: Index value '"
 244               + index + "' not in range [0.."
 245               + (this._sequenceSetList.size() - 1) + "]");
 246     }
 247
 248     return (SequenceSet) _sequenceSetList.get(index);
 249   }
 250
 251   /**
 252    * Method getSequenceSet.Returns the contents of the collection in an Array.
 253    * <p>
 254    * Note: Just in case the collection contents are changing in another thread,
 255    * we pass a 0-length Array of the correct type into the API call. This way we
 256    * <i>know</i> that the Array returned is of exactly the correct length.
 257    *
 258    * @return this collection as an Array
 259    */
 260   public SequenceSet[] getSequenceSet()
 261   {
 262     SequenceSet[] array = new SequenceSet[0];
 263     return (SequenceSet[]) this._sequenceSetList.toArray(array);
 264   }
 265
 266   /**
 267    * Method getSequenceSetCount.
 268    *
 269    * @return the size of this collection
 270    */
 271   public int getSequenceSetCount()
 272   {
 273     return this._sequenceSetList.size();
 274   }
 275
 276   /**
 277    * Method getTree.
 278    *
 279    * @param index
 280    * @throws java.lang.IndexOutOfBoundsException
 281    *           if the index given is outside the bounds of the collection
 282    * @return the value of the java.lang.String at the given index
 283    */
 284   public java.lang.String getTree(final int index)
 285           throws java.lang.IndexOutOfBoundsException
 286   {
 287     // check bounds for index
 288     if (index < 0 || index >= this._treeList.size())
 289     {
 290       throw new IndexOutOfBoundsException("getTree: Index value '" + index
 291               + "' not in range [0.." + (this._treeList.size() - 1) + "]");
 292     }
 293
 294     return (java.lang.String) _treeList.get(index);
 295   }
 296
 297   /**
 298    * Method getTree.Returns the contents of the collection in an Array.
 299    * <p>
 300    * Note: Just in case the collection contents are changing in another thread,
 301    * we pass a 0-length Array of the correct type into the API call. This way we
 302    * <i>know</i> that the Array returned is of exactly the correct length.
 303    *
 304    * @return this collection as an Array
 305    */
 306   public java.lang.String[] getTree()
 307   {
 308     java.lang.String[] array = new java.lang.String[0];
 309     return (java.lang.String[]) this._treeList.toArray(array);
 310   }
 311
 312   /**
 313    * Method getTreeCount.
 314    *
 315    * @return the size of this collection
 316    */
 317   public int getTreeCount()
 318   {
 319     return this._treeList.size();
 320   }
 321
 322   /**
 323    * Method isValid.
 324    *
 325    * @return true if this object is valid according to the schema
 326    */
 327   public boolean isValid()
 328   {
 329     try
 330     {
 331       validate();
 332     } catch (org.exolab.castor.xml.ValidationException vex)
 333     {
 334       return false;
 335     }
 336     return true;
 337   }
 338
 339   /**
 340    *
 341    *
 342    * @param out
 343    * @throws org.exolab.castor.xml.MarshalException
 344    *           if object is null or if any SAXException is thrown during
 345    *           marshaling
 346    * @throws org.exolab.castor.xml.ValidationException
 347    *           if this object is an invalid instance according to the schema
 348    */
 349   public void marshal(final java.io.Writer out)
 350           throws org.exolab.castor.xml.MarshalException,
 351           org.exolab.castor.xml.ValidationException
 352   {
 353     Marshaller.marshal(this, out);
 354   }
 355
 356   /**
 357    *
 358    *
 359    * @param handler
 360    * @throws java.io.IOException
 361    *           if an IOException occurs during marshaling
 362    * @throws org.exolab.castor.xml.ValidationException
 363    *           if this object is an invalid instance according to the schema
 364    * @throws org.exolab.castor.xml.MarshalException
 365    *           if object is null or if any SAXException is thrown during
 366    *           marshaling
 367    */
 368   public void marshal(final org.xml.sax.ContentHandler handler)
 369           throws java.io.IOException,
 370           org.exolab.castor.xml.MarshalException,
 371           org.exolab.castor.xml.ValidationException
 372   {
 373     Marshaller.marshal(this, handler);
 374   }
 375
 376   /**
 377    * Method removeAlignment.
 378    *
 379    * @param vAlignment
 380    * @return true if the object was removed from the collection.
 381    */
 382   public boolean removeAlignment(final Alignment vAlignment)
 383   {
 384     boolean removed = _alignmentList.remove(vAlignment);
 385     return removed;
 386   }
 387
 388   /**
 389    * Method removeAlignmentAt.
 390    *
 391    * @param index
 392    * @return the element removed from the collection
 393    */
 394   public Alignment removeAlignmentAt(final int index)
 395   {
 396     java.lang.Object obj = this._alignmentList.remove(index);
 397     return (Alignment) obj;
 398   }
 399
 400   /**
 401      */
 402   public void removeAllAlignment()
 403   {
 404     this._alignmentList.clear();
 405   }
 406
 407   /**
 408      */
 409   public void removeAllSequenceSet()
 410   {
 411     this._sequenceSetList.clear();
 412   }
 413
 414   /**
 415      */
 416   public void removeAllTree()
 417   {
 418     this._treeList.clear();
 419   }
 420
 421   /**
 422    * Method removeSequenceSet.
 423    *
 424    * @param vSequenceSet
 425    * @return true if the object was removed from the collection.
 426    */
 427   public boolean removeSequenceSet(final SequenceSet vSequenceSet)
 428   {
 429     boolean removed = _sequenceSetList.remove(vSequenceSet);
 430     return removed;
 431   }
 432
 433   /**
 434    * Method removeSequenceSetAt.
 435    *
 436    * @param index
 437    * @return the element removed from the collection
 438    */
 439   public SequenceSet removeSequenceSetAt(final int index)
 440   {
 441     java.lang.Object obj = this._sequenceSetList.remove(index);
 442     return (SequenceSet) obj;
 443   }
 444
 445   /**
 446    * Method removeTree.
 447    *
 448    * @param vTree
 449    * @return true if the object was removed from the collection.
 450    */
 451   public boolean removeTree(final java.lang.String vTree)
 452   {
 453     boolean removed = _treeList.remove(vTree);
 454     return removed;
 455   }
 456
 457   /**
 458    * Method removeTreeAt.
 459    *
 460    * @param index
 461    * @return the element removed from the collection
 462    */
 463   public java.lang.String removeTreeAt(final int index)
 464   {
 465     java.lang.Object obj = this._treeList.remove(index);
 466     return (java.lang.String) obj;
 467   }
 468
 469   /**
 470    *
 471    *
 472    * @param index
 473    * @param vAlignment
 474    * @throws java.lang.IndexOutOfBoundsException
 475    *           if the index given is outside the bounds of the collection
 476    */
 477   public void setAlignment(final int index, final Alignment vAlignment)
 478           throws java.lang.IndexOutOfBoundsException
 479   {
 480     // check bounds for index
 481     if (index < 0 || index >= this._alignmentList.size())
 482     {
 483       throw new IndexOutOfBoundsException("setAlignment: Index value '"
 484               + index + "' not in range [0.."
 485               + (this._alignmentList.size() - 1) + "]");
 486     }
 487
 488     this._alignmentList.set(index, vAlignment);
 489   }
 490
 491   /**
 492    *
 493    *
 494    * @param vAlignmentArray
 495    */
 496   public void setAlignment(final Alignment[] vAlignmentArray)
 497   {
 498     // -- copy array
 499     _alignmentList.clear();
 500
 501     for (int i = 0; i < vAlignmentArray.length; i++)
 502     {
 503       this._alignmentList.add(vAlignmentArray[i]);
 504     }
 505   }
 506
 507   /**
 508    *
 509    *
 510    * @param index
 511    * @param vSequenceSet
 512    * @throws java.lang.IndexOutOfBoundsException
 513    *           if the index given is outside the bounds of the collection
 514    */
 515   public void setSequenceSet(final int index, final SequenceSet vSequenceSet)
 516           throws java.lang.IndexOutOfBoundsException
 517   {
 518     // check bounds for index
 519     if (index < 0 || index >= this._sequenceSetList.size())
 520     {
 521       throw new IndexOutOfBoundsException("setSequenceSet: Index value '"
 522               + index + "' not in range [0.."
 523               + (this._sequenceSetList.size() - 1) + "]");
 524     }
 525
 526     this._sequenceSetList.set(index, vSequenceSet);
 527   }
 528
 529   /**
 530    *
 531    *
 532    * @param vSequenceSetArray
 533    */
 534   public void setSequenceSet(final SequenceSet[] vSequenceSetArray)
 535   {
 536     // -- copy array
 537     _sequenceSetList.clear();
 538
 539     for (int i = 0; i < vSequenceSetArray.length; i++)
 540     {
 541       this._sequenceSetList.add(vSequenceSetArray[i]);
 542     }
 543   }
 544
 545   /**
 546    *
 547    *
 548    * @param index
 549    * @param vTree
 550    * @throws java.lang.IndexOutOfBoundsException
 551    *           if the index given is outside the bounds of the collection
 552    */
 553   public void setTree(final int index, final java.lang.String vTree)
 554           throws java.lang.IndexOutOfBoundsException
 555   {
 556     // check bounds for index
 557     if (index < 0 || index >= this._treeList.size())
 558     {
 559       throw new IndexOutOfBoundsException("setTree: Index value '" + index
 560               + "' not in range [0.." + (this._treeList.size() - 1) + "]");
 561     }
 562
 563     this._treeList.set(index, vTree);
 564   }
 565
 566   /**
 567    *
 568    *
 569    * @param vTreeArray
 570    */
 571   public void setTree(final java.lang.String[] vTreeArray)
 572   {
 573     // -- copy array
 574     _treeList.clear();
 575
 576     for (int i = 0; i < vTreeArray.length; i++)
 577     {
 578       this._treeList.add(vTreeArray[i]);
 579     }
 580   }
 581
 582   /**
 583    * Method unmarshal.
 584    *
 585    * @param reader
 586    * @throws org.exolab.castor.xml.MarshalException
 587    *           if object is null or if any SAXException is thrown during
 588    *           marshaling
 589    * @throws org.exolab.castor.xml.ValidationException
 590    *           if this object is an invalid instance according to the schema
 591    * @return the unmarshaled jalview.binding.VAMSAS
 592    */
 593   public static jalview.binding.VAMSAS unmarshal(final java.io.Reader reader)
 594           throws org.exolab.castor.xml.MarshalException,
 595           org.exolab.castor.xml.ValidationException
 596   {
 597     return (jalview.binding.VAMSAS) Unmarshaller.unmarshal(
 598             jalview.binding.VAMSAS.class, reader);
 599   }
 600
 601   /**
 602    *
 603    *
 604    * @throws org.exolab.castor.xml.ValidationException
 605    *           if this object is an invalid instance according to the schema
 606    */
 607   public void validate() throws org.exolab.castor.xml.ValidationException
 608   {
 609     org.exolab.castor.xml.Validator validator = new org.exolab.castor.xml.Validator();
 610     validator.validate(this);
 611   }
 612
 613 }