src/uk/ac/vamsas/objects/core/Entry.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 Entry.
  19  *
  20  * @version $Revision$ $Date$
  21  */
  22 public class Entry extends uk.ac.vamsas.client.Vobject
  23 implements java.io.Serializable
  24 {
  25
  26
  27       //--------------------------/
  28      //- Class/Member Variables -/
  29     //--------------------------/
  30
  31     /**
  32      * Primary Key for vamsas object referencing
  33      *
  34      */
  35     private java.lang.String _id;
  36
  37     /**
  38      * Who
  39      */
  40     private java.lang.String _user;
  41
  42     /**
  43      * With which application
  44      */
  45     private java.lang.String _app;
  46
  47     /**
  48      * Did what
  49      */
  50     private java.lang.String _action;
  51
  52     /**
  53      * When
  54      */
  55     private java.util.Date _date;
  56
  57     /**
  58      * additional information
  59      */
  60     private java.util.Vector _propertyList;
  61
  62     /**
  63      * parameter for the action
  64      */
  65     private java.util.Vector _paramList;
  66
  67     /**
  68      * bioinformatic objects input to action
  69      *
  70      */
  71     private java.util.Vector _inputList;
  72
  73
  74       //----------------/
  75      //- Constructors -/
  76     //----------------/
  77
  78     public Entry() {
  79         super();
  80         this._propertyList = new java.util.Vector();
  81         this._paramList = new java.util.Vector();
  82         this._inputList = new java.util.Vector();
  83     }
  84
  85
  86       //-----------/
  87      //- Methods -/
  88     //-----------/
  89
  90     /**
  91      *
  92      *
  93      * @param vInput
  94      * @throws java.lang.IndexOutOfBoundsException if the index
  95      * given is outside the bounds of the collection
  96      */
  97     public void addInput(
  98             final uk.ac.vamsas.objects.core.Input vInput)
  99     throws java.lang.IndexOutOfBoundsException {
 100         this._inputList.addElement(vInput);
 101     }
 102
 103     /**
 104      *
 105      *
 106      * @param index
 107      * @param vInput
 108      * @throws java.lang.IndexOutOfBoundsException if the index
 109      * given is outside the bounds of the collection
 110      */
 111     public void addInput(
 112             final int index,
 113             final uk.ac.vamsas.objects.core.Input vInput)
 114     throws java.lang.IndexOutOfBoundsException {
 115         this._inputList.add(index, vInput);
 116     }
 117
 118     /**
 119      *
 120      *
 121      * @param vParam
 122      * @throws java.lang.IndexOutOfBoundsException if the index
 123      * given is outside the bounds of the collection
 124      */
 125     public void addParam(
 126             final uk.ac.vamsas.objects.core.Param vParam)
 127     throws java.lang.IndexOutOfBoundsException {
 128         this._paramList.addElement(vParam);
 129     }
 130
 131     /**
 132      *
 133      *
 134      * @param index
 135      * @param vParam
 136      * @throws java.lang.IndexOutOfBoundsException if the index
 137      * given is outside the bounds of the collection
 138      */
 139     public void addParam(
 140             final int index,
 141             final uk.ac.vamsas.objects.core.Param vParam)
 142     throws java.lang.IndexOutOfBoundsException {
 143         this._paramList.add(index, vParam);
 144     }
 145
 146     /**
 147      *
 148      *
 149      * @param vProperty
 150      * @throws java.lang.IndexOutOfBoundsException if the index
 151      * given is outside the bounds of the collection
 152      */
 153     public void addProperty(
 154             final uk.ac.vamsas.objects.core.Property vProperty)
 155     throws java.lang.IndexOutOfBoundsException {
 156         this._propertyList.addElement(vProperty);
 157     }
 158
 159     /**
 160      *
 161      *
 162      * @param index
 163      * @param vProperty
 164      * @throws java.lang.IndexOutOfBoundsException if the index
 165      * given is outside the bounds of the collection
 166      */
 167     public void addProperty(
 168             final int index,
 169             final uk.ac.vamsas.objects.core.Property vProperty)
 170     throws java.lang.IndexOutOfBoundsException {
 171         this._propertyList.add(index, vProperty);
 172     }
 173
 174     /**
 175      * Method enumerateInput.
 176      *
 177      * @return an Enumeration over all
 178      * uk.ac.vamsas.objects.core.Input elements
 179      */
 180     public java.util.Enumeration enumerateInput(
 181     ) {
 182         return this._inputList.elements();
 183     }
 184
 185     /**
 186      * Method enumerateParam.
 187      *
 188      * @return an Enumeration over all
 189      * uk.ac.vamsas.objects.core.Param elements
 190      */
 191     public java.util.Enumeration enumerateParam(
 192     ) {
 193         return this._paramList.elements();
 194     }
 195
 196     /**
 197      * Method enumerateProperty.
 198      *
 199      * @return an Enumeration over all
 200      * uk.ac.vamsas.objects.core.Property elements
 201      */
 202     public java.util.Enumeration enumerateProperty(
 203     ) {
 204         return this._propertyList.elements();
 205     }
 206
 207     /**
 208      * Overrides the java.lang.Object.equals method.
 209      *
 210      * @param obj
 211      * @return true if the objects are equal.
 212      */
 213     public boolean equals(
 214             final java.lang.Object obj) {
 215         if ( this == obj )
 216             return true;
 217
 218         if (super.equals(obj)==false)
 219             return false;
 220
 221         if (obj instanceof Entry) {
 222
 223             Entry temp = (Entry)obj;
 224             boolean thcycle;
 225             boolean tmcycle;
 226             if (this._id != null) {
 227                 if (temp._id == null) return false;
 228                 if (this._id != temp._id) {
 229                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._id);
 230                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._id);
 231                     if (thcycle!=tmcycle) {
 232                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._id); };
 233                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._id); };
 234                         return false;
 235                     }
 236                     if (!thcycle) {
 237                         if (!this._id.equals(temp._id)) {
 238                             org.castor.util.CycleBreaker.releaseCycleHandle(this._id);
 239                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._id);
 240                             return false;
 241                         }
 242                         org.castor.util.CycleBreaker.releaseCycleHandle(this._id);
 243                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._id);
 244                     }
 245                 }
 246             } else if (temp._id != null)
 247                 return false;
 248             if (this._user != null) {
 249                 if (temp._user == null) return false;
 250                 if (this._user != temp._user) {
 251                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._user);
 252                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._user);
 253                     if (thcycle!=tmcycle) {
 254                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._user); };
 255                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._user); };
 256                         return false;
 257                     }
 258                     if (!thcycle) {
 259                         if (!this._user.equals(temp._user)) {
 260                             org.castor.util.CycleBreaker.releaseCycleHandle(this._user);
 261                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._user);
 262                             return false;
 263                         }
 264                         org.castor.util.CycleBreaker.releaseCycleHandle(this._user);
 265                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._user);
 266                     }
 267                 }
 268             } else if (temp._user != null)
 269                 return false;
 270             if (this._app != null) {
 271                 if (temp._app == null) return false;
 272                 if (this._app != temp._app) {
 273                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._app);
 274                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._app);
 275                     if (thcycle!=tmcycle) {
 276                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._app); };
 277                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._app); };
 278                         return false;
 279                     }
 280                     if (!thcycle) {
 281                         if (!this._app.equals(temp._app)) {
 282                             org.castor.util.CycleBreaker.releaseCycleHandle(this._app);
 283                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._app);
 284                             return false;
 285                         }
 286                         org.castor.util.CycleBreaker.releaseCycleHandle(this._app);
 287                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._app);
 288                     }
 289                 }
 290             } else if (temp._app != null)
 291                 return false;
 292             if (this._action != null) {
 293                 if (temp._action == null) return false;
 294                 if (this._action != temp._action) {
 295                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._action);
 296                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._action);
 297                     if (thcycle!=tmcycle) {
 298                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._action); };
 299                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._action); };
 300                         return false;
 301                     }
 302                     if (!thcycle) {
 303                         if (!this._action.equals(temp._action)) {
 304                             org.castor.util.CycleBreaker.releaseCycleHandle(this._action);
 305                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._action);
 306                             return false;
 307                         }
 308                         org.castor.util.CycleBreaker.releaseCycleHandle(this._action);
 309                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._action);
 310                     }
 311                 }
 312             } else if (temp._action != null)
 313                 return false;
 314             if (this._date != null) {
 315                 if (temp._date == null) return false;
 316                 if (this._date != temp._date) {
 317                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._date);
 318                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._date);
 319                     if (thcycle!=tmcycle) {
 320                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._date); };
 321                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._date); };
 322                         return false;
 323                     }
 324                     if (!thcycle) {
 325                         if (!this._date.equals(temp._date)) {
 326                             org.castor.util.CycleBreaker.releaseCycleHandle(this._date);
 327                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._date);
 328                             return false;
 329                         }
 330                         org.castor.util.CycleBreaker.releaseCycleHandle(this._date);
 331                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._date);
 332                     }
 333                 }
 334             } else if (temp._date != null)
 335                 return false;
 336             if (this._propertyList != null) {
 337                 if (temp._propertyList == null) return false;
 338                 if (this._propertyList != temp._propertyList) {
 339                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._propertyList);
 340                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._propertyList);
 341                     if (thcycle!=tmcycle) {
 342                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._propertyList); };
 343                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._propertyList); };
 344                         return false;
 345                     }
 346                     if (!thcycle) {
 347                         if (!this._propertyList.equals(temp._propertyList)) {
 348                             org.castor.util.CycleBreaker.releaseCycleHandle(this._propertyList);
 349                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._propertyList);
 350                             return false;
 351                         }
 352                         org.castor.util.CycleBreaker.releaseCycleHandle(this._propertyList);
 353                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._propertyList);
 354                     }
 355                 }
 356             } else if (temp._propertyList != null)
 357                 return false;
 358             if (this._paramList != null) {
 359                 if (temp._paramList == null) return false;
 360                 if (this._paramList != temp._paramList) {
 361                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._paramList);
 362                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._paramList);
 363                     if (thcycle!=tmcycle) {
 364                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._paramList); };
 365                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._paramList); };
 366                         return false;
 367                     }
 368                     if (!thcycle) {
 369                         if (!this._paramList.equals(temp._paramList)) {
 370                             org.castor.util.CycleBreaker.releaseCycleHandle(this._paramList);
 371                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._paramList);
 372                             return false;
 373                         }
 374                         org.castor.util.CycleBreaker.releaseCycleHandle(this._paramList);
 375                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._paramList);
 376                     }
 377                 }
 378             } else if (temp._paramList != null)
 379                 return false;
 380             if (this._inputList != null) {
 381                 if (temp._inputList == null) return false;
 382                 if (this._inputList != temp._inputList) {
 383                     thcycle=org.castor.util.CycleBreaker.startingToCycle(this._inputList);
 384                     tmcycle=org.castor.util.CycleBreaker.startingToCycle(temp._inputList);
 385                     if (thcycle!=tmcycle) {
 386                         if (!thcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(this._inputList); };
 387                         if (!tmcycle) { org.castor.util.CycleBreaker.releaseCycleHandle(temp._inputList); };
 388                         return false;
 389                     }
 390                     if (!thcycle) {
 391                         if (!this._inputList.equals(temp._inputList)) {
 392                             org.castor.util.CycleBreaker.releaseCycleHandle(this._inputList);
 393                             org.castor.util.CycleBreaker.releaseCycleHandle(temp._inputList);
 394                             return false;
 395                         }
 396                         org.castor.util.CycleBreaker.releaseCycleHandle(this._inputList);
 397                         org.castor.util.CycleBreaker.releaseCycleHandle(temp._inputList);
 398                     }
 399                 }
 400             } else if (temp._inputList != null)
 401                 return false;
 402             return true;
 403         }
 404         return false;
 405     }
 406
 407     /**
 408      * Returns the value of field 'action'. The field 'action' has
 409      * the following description: Did what
 410      *
 411      * @return the value of field 'Action'.
 412      */
 413     public java.lang.String getAction(
 414     ) {
 415         return this._action;
 416     }
 417
 418     /**
 419      * Returns the value of field 'app'. The field 'app' has the
 420      * following description: With which application
 421      *
 422      * @return the value of field 'App'.
 423      */
 424     public java.lang.String getApp(
 425     ) {
 426         return this._app;
 427     }
 428
 429     /**
 430      * Returns the value of field 'date'. The field 'date' has the
 431      * following description: When
 432      *
 433      * @return the value of field 'Date'.
 434      */
 435     public java.util.Date getDate(
 436     ) {
 437         return this._date;
 438     }
 439
 440     /**
 441      * Returns the value of field 'id'. The field 'id' has the
 442      * following description: Primary Key for vamsas object
 443      * referencing
 444      *
 445      *
 446      * @return the value of field 'Id'.
 447      */
 448     public java.lang.String getId(
 449     ) {
 450         return this._id;
 451     }
 452
 453     /**
 454      * Method getInput.
 455      *
 456      * @param index
 457      * @throws java.lang.IndexOutOfBoundsException if the index
 458      * given is outside the bounds of the collection
 459      * @return the value of the uk.ac.vamsas.objects.core.Input at
 460      * the given index
 461      */
 462     public uk.ac.vamsas.objects.core.Input getInput(
 463             final int index)
 464     throws java.lang.IndexOutOfBoundsException {
 465         // check bounds for index
 466         if (index < 0 || index >= this._inputList.size()) {
 467             throw new IndexOutOfBoundsException("getInput: Index value '" + index + "' not in range [0.." + (this._inputList.size() - 1) + "]");
 468         }
 469
 470         return (uk.ac.vamsas.objects.core.Input) _inputList.get(index);
 471     }
 472
 473     /**
 474      * Method getInput.Returns the contents of the collection in an
 475      * Array.  <p>Note:  Just in case the collection contents are
 476      * changing in another thread, we pass a 0-length Array of the
 477      * correct type into the API call.  This way we <i>know</i>
 478      * that the Array returned is of exactly the correct length.
 479      *
 480      * @return this collection as an Array
 481      */
 482     public uk.ac.vamsas.objects.core.Input[] getInput(
 483     ) {
 484         uk.ac.vamsas.objects.core.Input[] array = new uk.ac.vamsas.objects.core.Input[0];
 485         return (uk.ac.vamsas.objects.core.Input[]) this._inputList.toArray(array);
 486     }
 487
 488     /**
 489      * Method getInputAsReference.Returns a reference to
 490      * '_inputList'. No type checking is performed on any
 491      * modifications to the Vector.
 492      *
 493      * @return a reference to the Vector backing this class
 494      */
 495     public java.util.Vector getInputAsReference(
 496     ) {
 497         return this._inputList;
 498     }
 499
 500     /**
 501      * Method getInputCount.
 502      *
 503      * @return the size of this collection
 504      */
 505     public int getInputCount(
 506     ) {
 507         return this._inputList.size();
 508     }
 509
 510     /**
 511      * Method getParam.
 512      *
 513      * @param index
 514      * @throws java.lang.IndexOutOfBoundsException if the index
 515      * given is outside the bounds of the collection
 516      * @return the value of the uk.ac.vamsas.objects.core.Param at
 517      * the given index
 518      */
 519     public uk.ac.vamsas.objects.core.Param getParam(
 520             final int index)
 521     throws java.lang.IndexOutOfBoundsException {
 522         // check bounds for index
 523         if (index < 0 || index >= this._paramList.size()) {
 524             throw new IndexOutOfBoundsException("getParam: Index value '" + index + "' not in range [0.." + (this._paramList.size() - 1) + "]");
 525         }
 526
 527         return (uk.ac.vamsas.objects.core.Param) _paramList.get(index);
 528     }
 529
 530     /**
 531      * Method getParam.Returns the contents of the collection in an
 532      * Array.  <p>Note:  Just in case the collection contents are
 533      * changing in another thread, we pass a 0-length Array of the
 534      * correct type into the API call.  This way we <i>know</i>
 535      * that the Array returned is of exactly the correct length.
 536      *
 537      * @return this collection as an Array
 538      */
 539     public uk.ac.vamsas.objects.core.Param[] getParam(
 540     ) {
 541         uk.ac.vamsas.objects.core.Param[] array = new uk.ac.vamsas.objects.core.Param[0];
 542         return (uk.ac.vamsas.objects.core.Param[]) this._paramList.toArray(array);
 543     }
 544
 545     /**
 546      * Method getParamAsReference.Returns a reference to
 547      * '_paramList'. No type checking is performed on any
 548      * modifications to the Vector.
 549      *
 550      * @return a reference to the Vector backing this class
 551      */
 552     public java.util.Vector getParamAsReference(
 553     ) {
 554         return this._paramList;
 555     }
 556
 557     /**
 558      * Method getParamCount.
 559      *
 560      * @return the size of this collection
 561      */
 562     public int getParamCount(
 563     ) {
 564         return this._paramList.size();
 565     }
 566
 567     /**
 568      * Method getProperty.
 569      *
 570      * @param index
 571      * @throws java.lang.IndexOutOfBoundsException if the index
 572      * given is outside the bounds of the collection
 573      * @return the value of the uk.ac.vamsas.objects.core.Property
 574      * at the given index
 575      */
 576     public uk.ac.vamsas.objects.core.Property getProperty(
 577             final int index)
 578     throws java.lang.IndexOutOfBoundsException {
 579         // check bounds for index
 580         if (index < 0 || index >= this._propertyList.size()) {
 581             throw new IndexOutOfBoundsException("getProperty: Index value '" + index + "' not in range [0.." + (this._propertyList.size() - 1) + "]");
 582         }
 583
 584         return (uk.ac.vamsas.objects.core.Property) _propertyList.get(index);
 585     }
 586
 587     /**
 588      * Method getProperty.Returns the contents of the collection in
 589      * an Array.  <p>Note:  Just in case the collection contents
 590      * are changing in another thread, we pass a 0-length Array of
 591      * the correct type into the API call.  This way we <i>know</i>
 592      * that the Array returned is of exactly the correct length.
 593      *
 594      * @return this collection as an Array
 595      */
 596     public uk.ac.vamsas.objects.core.Property[] getProperty(
 597     ) {
 598         uk.ac.vamsas.objects.core.Property[] array = new uk.ac.vamsas.objects.core.Property[0];
 599         return (uk.ac.vamsas.objects.core.Property[]) this._propertyList.toArray(array);
 600     }
 601
 602     /**
 603      * Method getPropertyAsReference.Returns a reference to
 604      * '_propertyList'. No type checking is performed on any
 605      * modifications to the Vector.
 606      *
 607      * @return a reference to the Vector backing this class
 608      */
 609     public java.util.Vector getPropertyAsReference(
 610     ) {
 611         return this._propertyList;
 612     }
 613
 614     /**
 615      * Method getPropertyCount.
 616      *
 617      * @return the size of this collection
 618      */
 619     public int getPropertyCount(
 620     ) {
 621         return this._propertyList.size();
 622     }
 623
 624     /**
 625      * Returns the value of field 'user'. The field 'user' has the
 626      * following description: Who
 627      *
 628      * @return the value of field 'User'.
 629      */
 630     public java.lang.String getUser(
 631     ) {
 632         return this._user;
 633     }
 634
 635     /**
 636      * Overrides the java.lang.Object.hashCode method.
 637      * <p>
 638      * The following steps came from <b>Effective Java Programming
 639      * Language Guide</b> by Joshua Bloch, Chapter 3
 640      *
 641      * @return a hash code value for the object.
 642      */
 643     public int hashCode(
 644     ) {
 645         int result = super.hashCode();
 646
 647         long tmp;
 648         if (_id != null
 649             && !org.castor.util.CycleBreaker.startingToCycle(_id)) {
 650            result = 37 * result + _id.hashCode();
 651            org.castor.util.CycleBreaker.releaseCycleHandle(_id);
 652         }
 653         if (_user != null
 654             && !org.castor.util.CycleBreaker.startingToCycle(_user)) {
 655            result = 37 * result + _user.hashCode();
 656            org.castor.util.CycleBreaker.releaseCycleHandle(_user);
 657         }
 658         if (_app != null
 659             && !org.castor.util.CycleBreaker.startingToCycle(_app)) {
 660            result = 37 * result + _app.hashCode();
 661            org.castor.util.CycleBreaker.releaseCycleHandle(_app);
 662         }
 663         if (_action != null
 664             && !org.castor.util.CycleBreaker.startingToCycle(_action)) {
 665            result = 37 * result + _action.hashCode();
 666            org.castor.util.CycleBreaker.releaseCycleHandle(_action);
 667         }
 668         if (_date != null
 669             && !org.castor.util.CycleBreaker.startingToCycle(_date)) {
 670            result = 37 * result + _date.hashCode();
 671            org.castor.util.CycleBreaker.releaseCycleHandle(_date);
 672         }
 673         if (_propertyList != null
 674             && !org.castor.util.CycleBreaker.startingToCycle(_propertyList)) {
 675            result = 37 * result + _propertyList.hashCode();
 676            org.castor.util.CycleBreaker.releaseCycleHandle(_propertyList);
 677         }
 678         if (_paramList != null
 679             && !org.castor.util.CycleBreaker.startingToCycle(_paramList)) {
 680            result = 37 * result + _paramList.hashCode();
 681            org.castor.util.CycleBreaker.releaseCycleHandle(_paramList);
 682         }
 683         if (_inputList != null
 684             && !org.castor.util.CycleBreaker.startingToCycle(_inputList)) {
 685            result = 37 * result + _inputList.hashCode();
 686            org.castor.util.CycleBreaker.releaseCycleHandle(_inputList);
 687         }
 688
 689         return result;
 690     }
 691
 692     /**
 693      * Method isValid.
 694      *
 695      * @return true if this object is valid according to the schema
 696      */
 697     public boolean isValid(
 698     ) {
 699         try {
 700             validate();
 701         } catch (org.exolab.castor.xml.ValidationException vex) {
 702             return false;
 703         }
 704         return true;
 705     }
 706
 707     /**
 708      *
 709      *
 710      * @param out
 711      * @throws org.exolab.castor.xml.MarshalException if object is
 712      * null or if any SAXException is thrown during marshaling
 713      * @throws org.exolab.castor.xml.ValidationException if this
 714      * object is an invalid instance according to the schema
 715      */
 716     public void marshal(
 717             final java.io.Writer out)
 718     throws org.exolab.castor.xml.MarshalException, org.exolab.castor.xml.ValidationException {
 719         Marshaller.marshal(this, out);
 720     }
 721
 722     /**
 723      *
 724      *
 725      * @param handler
 726      * @throws java.io.IOException if an IOException occurs during
 727      * marshaling
 728      * @throws org.exolab.castor.xml.ValidationException if this
 729      * object is an invalid instance according to the schema
 730      * @throws org.exolab.castor.xml.MarshalException if object is
 731      * null or if any SAXException is thrown during marshaling
 732      */
 733     public void marshal(
 734             final org.xml.sax.ContentHandler handler)
 735     throws java.io.IOException, org.exolab.castor.xml.MarshalException, org.exolab.castor.xml.ValidationException {
 736         Marshaller.marshal(this, handler);
 737     }
 738
 739     /**
 740      */
 741     public void removeAllInput(
 742     ) {
 743         this._inputList.clear();
 744     }
 745
 746     /**
 747      */
 748     public void removeAllParam(
 749     ) {
 750         this._paramList.clear();
 751     }
 752
 753     /**
 754      */
 755     public void removeAllProperty(
 756     ) {
 757         this._propertyList.clear();
 758     }
 759
 760     /**
 761      * Method removeInput.
 762      *
 763      * @param vInput
 764      * @return true if the object was removed from the collection.
 765      */
 766     public boolean removeInput(
 767             final uk.ac.vamsas.objects.core.Input vInput) {
 768         boolean removed = _inputList.remove(vInput);
 769         return removed;
 770     }
 771
 772     /**
 773      * Method removeInputAt.
 774      *
 775      * @param index
 776      * @return the element removed from the collection
 777      */
 778     public uk.ac.vamsas.objects.core.Input removeInputAt(
 779             final int index) {
 780         java.lang.Object obj = this._inputList.remove(index);
 781         return (uk.ac.vamsas.objects.core.Input) obj;
 782     }
 783
 784     /**
 785      * Method removeParam.
 786      *
 787      * @param vParam
 788      * @return true if the object was removed from the collection.
 789      */
 790     public boolean removeParam(
 791             final uk.ac.vamsas.objects.core.Param vParam) {
 792         boolean removed = _paramList.remove(vParam);
 793         return removed;
 794     }
 795
 796     /**
 797      * Method removeParamAt.
 798      *
 799      * @param index
 800      * @return the element removed from the collection
 801      */
 802     public uk.ac.vamsas.objects.core.Param removeParamAt(
 803             final int index) {
 804         java.lang.Object obj = this._paramList.remove(index);
 805         return (uk.ac.vamsas.objects.core.Param) obj;
 806     }
 807
 808     /**
 809      * Method removeProperty.
 810      *
 811      * @param vProperty
 812      * @return true if the object was removed from the collection.
 813      */
 814     public boolean removeProperty(
 815             final uk.ac.vamsas.objects.core.Property vProperty) {
 816         boolean removed = _propertyList.remove(vProperty);
 817         return removed;
 818     }
 819
 820     /**
 821      * Method removePropertyAt.
 822      *
 823      * @param index
 824      * @return the element removed from the collection
 825      */
 826     public uk.ac.vamsas.objects.core.Property removePropertyAt(
 827             final int index) {
 828         java.lang.Object obj = this._propertyList.remove(index);
 829         return (uk.ac.vamsas.objects.core.Property) obj;
 830     }
 831
 832     /**
 833      * Sets the value of field 'action'. The field 'action' has the
 834      * following description: Did what
 835      *
 836      * @param action the value of field 'action'.
 837      */
 838     public void setAction(
 839             final java.lang.String action) {
 840         this._action = action;
 841     }
 842
 843     /**
 844      * Sets the value of field 'app'. The field 'app' has the
 845      * following description: With which application
 846      *
 847      * @param app the value of field 'app'.
 848      */
 849     public void setApp(
 850             final java.lang.String app) {
 851         this._app = app;
 852     }
 853
 854     /**
 855      * Sets the value of field 'date'. The field 'date' has the
 856      * following description: When
 857      *
 858      * @param date the value of field 'date'.
 859      */
 860     public void setDate(
 861             final java.util.Date date) {
 862         this._date = date;
 863     }
 864
 865     /**
 866      * Sets the value of field 'id'. The field 'id' has the
 867      * following description: Primary Key for vamsas object
 868      * referencing
 869      *
 870      *
 871      * @param id the value of field 'id'.
 872      */
 873     public void setId(
 874             final java.lang.String id) {
 875         this._id = id;
 876     }
 877
 878     /**
 879      *
 880      *
 881      * @param index
 882      * @param vInput
 883      * @throws java.lang.IndexOutOfBoundsException if the index
 884      * given is outside the bounds of the collection
 885      */
 886     public void setInput(
 887             final int index,
 888             final uk.ac.vamsas.objects.core.Input vInput)
 889     throws java.lang.IndexOutOfBoundsException {
 890         // check bounds for index
 891         if (index < 0 || index >= this._inputList.size()) {
 892             throw new IndexOutOfBoundsException("setInput: Index value '" + index + "' not in range [0.." + (this._inputList.size() - 1) + "]");
 893         }
 894
 895         this._inputList.set(index, vInput);
 896     }
 897
 898     /**
 899      *
 900      *
 901      * @param vInputArray
 902      */
 903     public void setInput(
 904             final uk.ac.vamsas.objects.core.Input[] vInputArray) {
 905         //-- copy array
 906         _inputList.clear();
 907
 908         for (int i = 0; i < vInputArray.length; i++) {
 909                 this._inputList.add(vInputArray[i]);
 910         }
 911     }
 912
 913     /**
 914      * Sets the value of '_inputList' by copying the given Vector.
 915      * All elements will be checked for type safety.
 916      *
 917      * @param vInputList the Vector to copy.
 918      */
 919     public void setInput(
 920             final java.util.Vector vInputList) {
 921         // copy vector
 922         this._inputList.clear();
 923
 924         this._inputList.addAll(vInputList);
 925     }
 926
 927     /**
 928      * Sets the value of '_inputList' by setting it to the given
 929      * Vector. No type checking is performed.
 930      * @deprecated
 931      *
 932      * @param inputVector the Vector to set.
 933      */
 934     public void setInputAsReference(
 935             final java.util.Vector inputVector) {
 936         this._inputList = inputVector;
 937     }
 938
 939     /**
 940      *
 941      *
 942      * @param index
 943      * @param vParam
 944      * @throws java.lang.IndexOutOfBoundsException if the index
 945      * given is outside the bounds of the collection
 946      */
 947     public void setParam(
 948             final int index,
 949             final uk.ac.vamsas.objects.core.Param vParam)
 950     throws java.lang.IndexOutOfBoundsException {
 951         // check bounds for index
 952         if (index < 0 || index >= this._paramList.size()) {
 953             throw new IndexOutOfBoundsException("setParam: Index value '" + index + "' not in range [0.." + (this._paramList.size() - 1) + "]");
 954         }
 955
 956         this._paramList.set(index, vParam);
 957     }
 958
 959     /**
 960      *
 961      *
 962      * @param vParamArray
 963      */
 964     public void setParam(
 965             final uk.ac.vamsas.objects.core.Param[] vParamArray) {
 966         //-- copy array
 967         _paramList.clear();
 968
 969         for (int i = 0; i < vParamArray.length; i++) {
 970                 this._paramList.add(vParamArray[i]);
 971         }
 972     }
 973
 974     /**
 975      * Sets the value of '_paramList' by copying the given Vector.
 976      * All elements will be checked for type safety.
 977      *
 978      * @param vParamList the Vector to copy.
 979      */
 980     public void setParam(
 981             final java.util.Vector vParamList) {
 982         // copy vector
 983         this._paramList.clear();
 984
 985         this._paramList.addAll(vParamList);
 986     }
 987
 988     /**
 989      * Sets the value of '_paramList' by setting it to the given
 990      * Vector. No type checking is performed.
 991      * @deprecated
 992      *
 993      * @param paramVector the Vector to set.
 994      */
 995     public void setParamAsReference(
 996             final java.util.Vector paramVector) {
 997         this._paramList = paramVector;
 998     }
 999
1000     /**
1001      *
1002      *
1003      * @param index
1004      * @param vProperty
1005      * @throws java.lang.IndexOutOfBoundsException if the index
1006      * given is outside the bounds of the collection
1007      */
1008     public void setProperty(
1009             final int index,
1010             final uk.ac.vamsas.objects.core.Property vProperty)
1011     throws java.lang.IndexOutOfBoundsException {
1012         // check bounds for index
1013         if (index < 0 || index >= this._propertyList.size()) {
1014             throw new IndexOutOfBoundsException("setProperty: Index value '" + index + "' not in range [0.." + (this._propertyList.size() - 1) + "]");
1015         }
1016
1017         this._propertyList.set(index, vProperty);
1018     }
1019
1020     /**
1021      *
1022      *
1023      * @param vPropertyArray
1024      */
1025     public void setProperty(
1026             final uk.ac.vamsas.objects.core.Property[] vPropertyArray) {
1027         //-- copy array
1028         _propertyList.clear();
1029
1030         for (int i = 0; i < vPropertyArray.length; i++) {
1031                 this._propertyList.add(vPropertyArray[i]);
1032         }
1033     }
1034
1035     /**
1036      * Sets the value of '_propertyList' by copying the given
1037      * Vector. All elements will be checked for type safety.
1038      *
1039      * @param vPropertyList the Vector to copy.
1040      */
1041     public void setProperty(
1042             final java.util.Vector vPropertyList) {
1043         // copy vector
1044         this._propertyList.clear();
1045
1046         this._propertyList.addAll(vPropertyList);
1047     }
1048
1049     /**
1050      * Sets the value of '_propertyList' by setting it to the given
1051      * Vector. No type checking is performed.
1052      * @deprecated
1053      *
1054      * @param propertyVector the Vector to set.
1055      */
1056     public void setPropertyAsReference(
1057             final java.util.Vector propertyVector) {
1058         this._propertyList = propertyVector;
1059     }
1060
1061     /**
1062      * Sets the value of field 'user'. The field 'user' has the
1063      * following description: Who
1064      *
1065      * @param user the value of field 'user'.
1066      */
1067     public void setUser(
1068             final java.lang.String user) {
1069         this._user = user;
1070     }
1071
1072     /**
1073      * Method unmarshal.
1074      *
1075      * @param reader
1076      * @throws org.exolab.castor.xml.MarshalException if object is
1077      * null or if any SAXException is thrown during marshaling
1078      * @throws org.exolab.castor.xml.ValidationException if this
1079      * object is an invalid instance according to the schema
1080      * @return the unmarshaled uk.ac.vamsas.objects.core.Entry
1081      */
1082     public static uk.ac.vamsas.objects.core.Entry unmarshal(
1083             final java.io.Reader reader)
1084     throws org.exolab.castor.xml.MarshalException, org.exolab.castor.xml.ValidationException {
1085         return (uk.ac.vamsas.objects.core.Entry) Unmarshaller.unmarshal(uk.ac.vamsas.objects.core.Entry.class, reader);
1086     }
1087
1088     /**
1089      *
1090      *
1091      * @throws org.exolab.castor.xml.ValidationException if this
1092      * object is an invalid instance according to the schema
1093      */
1094     public void validate(
1095     )
1096     throws org.exolab.castor.xml.ValidationException {
1097         org.exolab.castor.xml.Validator validator = new org.exolab.castor.xml.Validator();
1098         validator.validate(this);
1099     }
1100
1101 }