src/jalview/xml/binding/uniprot/ProteinType.java

   1 //
   2 // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.8-b130911.1802
   3 // See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
   4 // Any modifications to this file will be lost upon recompilation of the source schema.
   5 // Generated on: 2019.04.05 at 08:01:44 AM BST
   6 //
   7
   8 package jalview.xml.binding.uniprot;
   9
  10 import java.util.ArrayList;
  11 import java.util.List;
  12 import javax.xml.bind.annotation.XmlAccessType;
  13 import javax.xml.bind.annotation.XmlAccessorType;
  14 import javax.xml.bind.annotation.XmlElement;
  15 import javax.xml.bind.annotation.XmlType;
  16
  17 /**
  18  * Describes the names for the protein and parts thereof. Equivalent to the flat
  19  * file DE-line.
  20  *
  21  * <p>
  22  * Java class for proteinType complex type.
  23  *
  24  * <p>
  25  * The following schema fragment specifies the expected content contained within
  26  * this class.
  27  *
  28  * <pre>
  29  * &lt;complexType name="proteinType">
  30  *   &lt;complexContent>
  31  *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
  32  *       &lt;sequence>
  33  *         &lt;group ref="{http://uniprot.org/uniprot}proteinNameGroup"/>
  34  *         &lt;element name="domain" maxOccurs="unbounded" minOccurs="0">
  35  *           &lt;complexType>
  36  *             &lt;complexContent>
  37  *               &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
  38  *                 &lt;group ref="{http://uniprot.org/uniprot}proteinNameGroup"/>
  39  *               &lt;/restriction>
  40  *             &lt;/complexContent>
  41  *           &lt;/complexType>
  42  *         &lt;/element>
  43  *         &lt;element name="component" maxOccurs="unbounded" minOccurs="0">
  44  *           &lt;complexType>
  45  *             &lt;complexContent>
  46  *               &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
  47  *                 &lt;group ref="{http://uniprot.org/uniprot}proteinNameGroup"/>
  48  *               &lt;/restriction>
  49  *             &lt;/complexContent>
  50  *           &lt;/complexType>
  51  *         &lt;/element>
  52  *       &lt;/sequence>
  53  *     &lt;/restriction>
  54  *   &lt;/complexContent>
  55  * &lt;/complexType>
  56  * </pre>
  57  *
  58  *
  59  */
  60 @XmlAccessorType(XmlAccessType.FIELD)
  61 @XmlType(
  62   name = "proteinType",
  63   propOrder =
  64   { "recommendedName", "alternativeName", "submittedName", "allergenName",
  65       "biotechName", "cdAntigenName", "innName", "domain", "component" })
  66 public class ProteinType
  67 {
  68
  69   protected ProteinType.RecommendedName recommendedName;
  70
  71   protected List<ProteinType.AlternativeName> alternativeName;
  72
  73   protected List<ProteinType.SubmittedName> submittedName;
  74
  75   protected EvidencedStringType allergenName;
  76
  77   protected EvidencedStringType biotechName;
  78
  79   protected List<EvidencedStringType> cdAntigenName;
  80
  81   protected List<EvidencedStringType> innName;
  82
  83   protected List<ProteinType.Domain> domain;
  84
  85   protected List<ProteinType.Component> component;
  86
  87   /**
  88    * Gets the value of the recommendedName property.
  89    *
  90    * @return possible object is {@link ProteinType.RecommendedName }
  91    *
  92    */
  93   public ProteinType.RecommendedName getRecommendedName()
  94   {
  95     return recommendedName;
  96   }
  97
  98   /**
  99    * Sets the value of the recommendedName property.
 100    *
 101    * @param value
 102    *          allowed object is {@link ProteinType.RecommendedName }
 103    *
 104    */
 105   public void setRecommendedName(ProteinType.RecommendedName value)
 106   {
 107     this.recommendedName = value;
 108   }
 109
 110   /**
 111    * Gets the value of the alternativeName property.
 112    *
 113    * <p>
 114    * This accessor method returns a reference to the live list, not a snapshot.
 115    * Therefore any modification you make to the returned list will be present
 116    * inside the JAXB object. This is why there is not a <CODE>set</CODE> method
 117    * for the alternativeName property.
 118    *
 119    * <p>
 120    * For example, to add a new item, do as follows:
 121    *
 122    * <pre>
 123    * getAlternativeName().add(newItem);
 124    * </pre>
 125    *
 126    *
 127    * <p>
 128    * Objects of the following type(s) are allowed in the list
 129    * {@link ProteinType.AlternativeName }
 130    *
 131    *
 132    */
 133   public List<ProteinType.AlternativeName> getAlternativeName()
 134   {
 135     if (alternativeName == null)
 136     {
 137       alternativeName = new ArrayList<ProteinType.AlternativeName>();
 138     }
 139     return this.alternativeName;
 140   }
 141
 142   /**
 143    * Gets the value of the submittedName property.
 144    *
 145    * <p>
 146    * This accessor method returns a reference to the live list, not a snapshot.
 147    * Therefore any modification you make to the returned list will be present
 148    * inside the JAXB object. This is why there is not a <CODE>set</CODE> method
 149    * for the submittedName property.
 150    *
 151    * <p>
 152    * For example, to add a new item, do as follows:
 153    *
 154    * <pre>
 155    * getSubmittedName().add(newItem);
 156    * </pre>
 157    *
 158    *
 159    * <p>
 160    * Objects of the following type(s) are allowed in the list
 161    * {@link ProteinType.SubmittedName }
 162    *
 163    *
 164    */
 165   public List<ProteinType.SubmittedName> getSubmittedName()
 166   {
 167     if (submittedName == null)
 168     {
 169       submittedName = new ArrayList<ProteinType.SubmittedName>();
 170     }
 171     return this.submittedName;
 172   }
 173
 174   /**
 175    * Gets the value of the allergenName property.
 176    *
 177    * @return possible object is {@link EvidencedStringType }
 178    *
 179    */
 180   public EvidencedStringType getAllergenName()
 181   {
 182     return allergenName;
 183   }
 184
 185   /**
 186    * Sets the value of the allergenName property.
 187    *
 188    * @param value
 189    *          allowed object is {@link EvidencedStringType }
 190    *
 191    */
 192   public void setAllergenName(EvidencedStringType value)
 193   {
 194     this.allergenName = value;
 195   }
 196
 197   /**
 198    * Gets the value of the biotechName property.
 199    *
 200    * @return possible object is {@link EvidencedStringType }
 201    *
 202    */
 203   public EvidencedStringType getBiotechName()
 204   {
 205     return biotechName;
 206   }
 207
 208   /**
 209    * Sets the value of the biotechName property.
 210    *
 211    * @param value
 212    *          allowed object is {@link EvidencedStringType }
 213    *
 214    */
 215   public void setBiotechName(EvidencedStringType value)
 216   {
 217     this.biotechName = value;
 218   }
 219
 220   /**
 221    * Gets the value of the cdAntigenName property.
 222    *
 223    * <p>
 224    * This accessor method returns a reference to the live list, not a snapshot.
 225    * Therefore any modification you make to the returned list will be present
 226    * inside the JAXB object. This is why there is not a <CODE>set</CODE> method
 227    * for the cdAntigenName property.
 228    *
 229    * <p>
 230    * For example, to add a new item, do as follows:
 231    *
 232    * <pre>
 233    * getCdAntigenName().add(newItem);
 234    * </pre>
 235    *
 236    *
 237    * <p>
 238    * Objects of the following type(s) are allowed in the list
 239    * {@link EvidencedStringType }
 240    *
 241    *
 242    */
 243   public List<EvidencedStringType> getCdAntigenName()
 244   {
 245     if (cdAntigenName == null)
 246     {
 247       cdAntigenName = new ArrayList<EvidencedStringType>();
 248     }
 249     return this.cdAntigenName;
 250   }
 251
 252   /**
 253    * Gets the value of the innName property.
 254    *
 255    * <p>
 256    * This accessor method returns a reference to the live list, not a snapshot.
 257    * Therefore any modification you make to the returned list will be present
 258    * inside the JAXB object. This is why there is not a <CODE>set</CODE> method
 259    * for the innName property.
 260    *
 261    * <p>
 262    * For example, to add a new item, do as follows:
 263    *
 264    * <pre>
 265    * getInnName().add(newItem);
 266    * </pre>
 267    *
 268    *
 269    * <p>
 270    * Objects of the following type(s) are allowed in the list
 271    * {@link EvidencedStringType }
 272    *
 273    *
 274    */
 275   public List<EvidencedStringType> getInnName()
 276   {
 277     if (innName == null)
 278     {
 279       innName = new ArrayList<EvidencedStringType>();
 280     }
 281     return this.innName;
 282   }
 283
 284   /**
 285    * Gets the value of the domain property.
 286    *
 287    * <p>
 288    * This accessor method returns a reference to the live list, not a snapshot.
 289    * Therefore any modification you make to the returned list will be present
 290    * inside the JAXB object. This is why there is not a <CODE>set</CODE> method
 291    * for the domain property.
 292    *
 293    * <p>
 294    * For example, to add a new item, do as follows:
 295    *
 296    * <pre>
 297    * getDomain().add(newItem);
 298    * </pre>
 299    *
 300    *
 301    * <p>
 302    * Objects of the following type(s) are allowed in the list
 303    * {@link ProteinType.Domain }
 304    *
 305    *
 306    */
 307   public List<ProteinType.Domain> getDomain()
 308   {
 309     if (domain == null)
 310     {
 311       domain = new ArrayList<ProteinType.Domain>();
 312     }
 313     return this.domain;
 314   }
 315
 316   /**
 317    * Gets the value of the component property.
 318    *
 319    * <p>
 320    * This accessor method returns a reference to the live list, not a snapshot.
 321    * Therefore any modification you make to the returned list will be present
 322    * inside the JAXB object. This is why there is not a <CODE>set</CODE> method
 323    * for the component property.
 324    *
 325    * <p>
 326    * For example, to add a new item, do as follows:
 327    *
 328    * <pre>
 329    * getComponent().add(newItem);
 330    * </pre>
 331    *
 332    *
 333    * <p>
 334    * Objects of the following type(s) are allowed in the list
 335    * {@link ProteinType.Component }
 336    *
 337    *
 338    */
 339   public List<ProteinType.Component> getComponent()
 340   {
 341     if (component == null)
 342     {
 343       component = new ArrayList<ProteinType.Component>();
 344     }
 345     return this.component;
 346   }
 347
 348   /**
 349    * <p>
 350    * Java class for anonymous complex type.
 351    *
 352    * <p>
 353    * The following schema fragment specifies the expected content contained
 354    * within this class.
 355    *
 356    * <pre>
 357    * &lt;complexType>
 358    *   &lt;complexContent>
 359    *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 360    *       &lt;sequence>
 361    *         &lt;element name="fullName" type="{http://uniprot.org/uniprot}evidencedStringType" minOccurs="0"/>
 362    *         &lt;element name="shortName" type="{http://uniprot.org/uniprot}evidencedStringType" maxOccurs="unbounded" minOccurs="0"/>
 363    *         &lt;element name="ecNumber" type="{http://uniprot.org/uniprot}evidencedStringType" maxOccurs="unbounded" minOccurs="0"/>
 364    *       &lt;/sequence>
 365    *     &lt;/restriction>
 366    *   &lt;/complexContent>
 367    * &lt;/complexType>
 368    * </pre>
 369    *
 370    *
 371    */
 372   @XmlAccessorType(XmlAccessType.FIELD)
 373   @XmlType(name = "", propOrder = { "fullName", "shortName", "ecNumber" })
 374   public static class AlternativeName
 375   {
 376
 377     protected EvidencedStringType fullName;
 378
 379     protected List<EvidencedStringType> shortName;
 380
 381     protected List<EvidencedStringType> ecNumber;
 382
 383     /**
 384      * Gets the value of the fullName property.
 385      *
 386      * @return possible object is {@link EvidencedStringType }
 387      *
 388      */
 389     public EvidencedStringType getFullName()
 390     {
 391       return fullName;
 392     }
 393
 394     /**
 395      * Sets the value of the fullName property.
 396      *
 397      * @param value
 398      *          allowed object is {@link EvidencedStringType }
 399      *
 400      */
 401     public void setFullName(EvidencedStringType value)
 402     {
 403       this.fullName = value;
 404     }
 405
 406     /**
 407      * Gets the value of the shortName property.
 408      *
 409      * <p>
 410      * This accessor method returns a reference to the live list, not a
 411      * snapshot. Therefore any modification you make to the returned list will
 412      * be present inside the JAXB object. This is why there is not a
 413      * <CODE>set</CODE> method for the shortName property.
 414      *
 415      * <p>
 416      * For example, to add a new item, do as follows:
 417      *
 418      * <pre>
 419      * getShortName().add(newItem);
 420      * </pre>
 421      *
 422      *
 423      * <p>
 424      * Objects of the following type(s) are allowed in the list
 425      * {@link EvidencedStringType }
 426      *
 427      *
 428      */
 429     public List<EvidencedStringType> getShortName()
 430     {
 431       if (shortName == null)
 432       {
 433         shortName = new ArrayList<EvidencedStringType>();
 434       }
 435       return this.shortName;
 436     }
 437
 438     /**
 439      * Gets the value of the ecNumber property.
 440      *
 441      * <p>
 442      * This accessor method returns a reference to the live list, not a
 443      * snapshot. Therefore any modification you make to the returned list will
 444      * be present inside the JAXB object. This is why there is not a
 445      * <CODE>set</CODE> method for the ecNumber property.
 446      *
 447      * <p>
 448      * For example, to add a new item, do as follows:
 449      *
 450      * <pre>
 451      * getEcNumber().add(newItem);
 452      * </pre>
 453      *
 454      *
 455      * <p>
 456      * Objects of the following type(s) are allowed in the list
 457      * {@link EvidencedStringType }
 458      *
 459      *
 460      */
 461     public List<EvidencedStringType> getEcNumber()
 462     {
 463       if (ecNumber == null)
 464       {
 465         ecNumber = new ArrayList<EvidencedStringType>();
 466       }
 467       return this.ecNumber;
 468     }
 469
 470   }
 471
 472   /**
 473    * <p>
 474    * Java class for anonymous complex type.
 475    *
 476    * <p>
 477    * The following schema fragment specifies the expected content contained
 478    * within this class.
 479    *
 480    * <pre>
 481    * &lt;complexType>
 482    *   &lt;complexContent>
 483    *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 484    *       &lt;group ref="{http://uniprot.org/uniprot}proteinNameGroup"/>
 485    *     &lt;/restriction>
 486    *   &lt;/complexContent>
 487    * &lt;/complexType>
 488    * </pre>
 489    *
 490    *
 491    */
 492   @XmlAccessorType(XmlAccessType.FIELD)
 493   @XmlType(
 494     name = "",
 495     propOrder =
 496     { "recommendedName", "alternativeName", "submittedName", "allergenName",
 497         "biotechName", "cdAntigenName", "innName" })
 498   public static class Component
 499   {
 500
 501     protected ProteinType.RecommendedName recommendedName;
 502
 503     protected List<ProteinType.AlternativeName> alternativeName;
 504
 505     protected List<ProteinType.SubmittedName> submittedName;
 506
 507     protected EvidencedStringType allergenName;
 508
 509     protected EvidencedStringType biotechName;
 510
 511     protected List<EvidencedStringType> cdAntigenName;
 512
 513     protected List<EvidencedStringType> innName;
 514
 515     /**
 516      * Gets the value of the recommendedName property.
 517      *
 518      * @return possible object is {@link ProteinType.RecommendedName }
 519      *
 520      */
 521     public ProteinType.RecommendedName getRecommendedName()
 522     {
 523       return recommendedName;
 524     }
 525
 526     /**
 527      * Sets the value of the recommendedName property.
 528      *
 529      * @param value
 530      *          allowed object is {@link ProteinType.RecommendedName }
 531      *
 532      */
 533     public void setRecommendedName(ProteinType.RecommendedName value)
 534     {
 535       this.recommendedName = value;
 536     }
 537
 538     /**
 539      * Gets the value of the alternativeName property.
 540      *
 541      * <p>
 542      * This accessor method returns a reference to the live list, not a
 543      * snapshot. Therefore any modification you make to the returned list will
 544      * be present inside the JAXB object. This is why there is not a
 545      * <CODE>set</CODE> method for the alternativeName property.
 546      *
 547      * <p>
 548      * For example, to add a new item, do as follows:
 549      *
 550      * <pre>
 551      * getAlternativeName().add(newItem);
 552      * </pre>
 553      *
 554      *
 555      * <p>
 556      * Objects of the following type(s) are allowed in the list
 557      * {@link ProteinType.AlternativeName }
 558      *
 559      *
 560      */
 561     public List<ProteinType.AlternativeName> getAlternativeName()
 562     {
 563       if (alternativeName == null)
 564       {
 565         alternativeName = new ArrayList<ProteinType.AlternativeName>();
 566       }
 567       return this.alternativeName;
 568     }
 569
 570     /**
 571      * Gets the value of the submittedName property.
 572      *
 573      * <p>
 574      * This accessor method returns a reference to the live list, not a
 575      * snapshot. Therefore any modification you make to the returned list will
 576      * be present inside the JAXB object. This is why there is not a
 577      * <CODE>set</CODE> method for the submittedName property.
 578      *
 579      * <p>
 580      * For example, to add a new item, do as follows:
 581      *
 582      * <pre>
 583      * getSubmittedName().add(newItem);
 584      * </pre>
 585      *
 586      *
 587      * <p>
 588      * Objects of the following type(s) are allowed in the list
 589      * {@link ProteinType.SubmittedName }
 590      *
 591      *
 592      */
 593     public List<ProteinType.SubmittedName> getSubmittedName()
 594     {
 595       if (submittedName == null)
 596       {
 597         submittedName = new ArrayList<ProteinType.SubmittedName>();
 598       }
 599       return this.submittedName;
 600     }
 601
 602     /**
 603      * Gets the value of the allergenName property.
 604      *
 605      * @return possible object is {@link EvidencedStringType }
 606      *
 607      */
 608     public EvidencedStringType getAllergenName()
 609     {
 610       return allergenName;
 611     }
 612
 613     /**
 614      * Sets the value of the allergenName property.
 615      *
 616      * @param value
 617      *          allowed object is {@link EvidencedStringType }
 618      *
 619      */
 620     public void setAllergenName(EvidencedStringType value)
 621     {
 622       this.allergenName = value;
 623     }
 624
 625     /**
 626      * Gets the value of the biotechName property.
 627      *
 628      * @return possible object is {@link EvidencedStringType }
 629      *
 630      */
 631     public EvidencedStringType getBiotechName()
 632     {
 633       return biotechName;
 634     }
 635
 636     /**
 637      * Sets the value of the biotechName property.
 638      *
 639      * @param value
 640      *          allowed object is {@link EvidencedStringType }
 641      *
 642      */
 643     public void setBiotechName(EvidencedStringType value)
 644     {
 645       this.biotechName = value;
 646     }
 647
 648     /**
 649      * Gets the value of the cdAntigenName property.
 650      *
 651      * <p>
 652      * This accessor method returns a reference to the live list, not a
 653      * snapshot. Therefore any modification you make to the returned list will
 654      * be present inside the JAXB object. This is why there is not a
 655      * <CODE>set</CODE> method for the cdAntigenName property.
 656      *
 657      * <p>
 658      * For example, to add a new item, do as follows:
 659      *
 660      * <pre>
 661      * getCdAntigenName().add(newItem);
 662      * </pre>
 663      *
 664      *
 665      * <p>
 666      * Objects of the following type(s) are allowed in the list
 667      * {@link EvidencedStringType }
 668      *
 669      *
 670      */
 671     public List<EvidencedStringType> getCdAntigenName()
 672     {
 673       if (cdAntigenName == null)
 674       {
 675         cdAntigenName = new ArrayList<EvidencedStringType>();
 676       }
 677       return this.cdAntigenName;
 678     }
 679
 680     /**
 681      * Gets the value of the innName property.
 682      *
 683      * <p>
 684      * This accessor method returns a reference to the live list, not a
 685      * snapshot. Therefore any modification you make to the returned list will
 686      * be present inside the JAXB object. This is why there is not a
 687      * <CODE>set</CODE> method for the innName property.
 688      *
 689      * <p>
 690      * For example, to add a new item, do as follows:
 691      *
 692      * <pre>
 693      * getInnName().add(newItem);
 694      * </pre>
 695      *
 696      *
 697      * <p>
 698      * Objects of the following type(s) are allowed in the list
 699      * {@link EvidencedStringType }
 700      *
 701      *
 702      */
 703     public List<EvidencedStringType> getInnName()
 704     {
 705       if (innName == null)
 706       {
 707         innName = new ArrayList<EvidencedStringType>();
 708       }
 709       return this.innName;
 710     }
 711
 712   }
 713
 714   /**
 715    * <p>
 716    * Java class for anonymous complex type.
 717    *
 718    * <p>
 719    * The following schema fragment specifies the expected content contained
 720    * within this class.
 721    *
 722    * <pre>
 723    * &lt;complexType>
 724    *   &lt;complexContent>
 725    *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 726    *       &lt;group ref="{http://uniprot.org/uniprot}proteinNameGroup"/>
 727    *     &lt;/restriction>
 728    *   &lt;/complexContent>
 729    * &lt;/complexType>
 730    * </pre>
 731    *
 732    *
 733    */
 734   @XmlAccessorType(XmlAccessType.FIELD)
 735   @XmlType(
 736     name = "",
 737     propOrder =
 738     { "recommendedName", "alternativeName", "submittedName", "allergenName",
 739         "biotechName", "cdAntigenName", "innName" })
 740   public static class Domain
 741   {
 742
 743     protected ProteinType.RecommendedName recommendedName;
 744
 745     protected List<ProteinType.AlternativeName> alternativeName;
 746
 747     protected List<ProteinType.SubmittedName> submittedName;
 748
 749     protected EvidencedStringType allergenName;
 750
 751     protected EvidencedStringType biotechName;
 752
 753     protected List<EvidencedStringType> cdAntigenName;
 754
 755     protected List<EvidencedStringType> innName;
 756
 757     /**
 758      * Gets the value of the recommendedName property.
 759      *
 760      * @return possible object is {@link ProteinType.RecommendedName }
 761      *
 762      */
 763     public ProteinType.RecommendedName getRecommendedName()
 764     {
 765       return recommendedName;
 766     }
 767
 768     /**
 769      * Sets the value of the recommendedName property.
 770      *
 771      * @param value
 772      *          allowed object is {@link ProteinType.RecommendedName }
 773      *
 774      */
 775     public void setRecommendedName(ProteinType.RecommendedName value)
 776     {
 777       this.recommendedName = value;
 778     }
 779
 780     /**
 781      * Gets the value of the alternativeName property.
 782      *
 783      * <p>
 784      * This accessor method returns a reference to the live list, not a
 785      * snapshot. Therefore any modification you make to the returned list will
 786      * be present inside the JAXB object. This is why there is not a
 787      * <CODE>set</CODE> method for the alternativeName property.
 788      *
 789      * <p>
 790      * For example, to add a new item, do as follows:
 791      *
 792      * <pre>
 793      * getAlternativeName().add(newItem);
 794      * </pre>
 795      *
 796      *
 797      * <p>
 798      * Objects of the following type(s) are allowed in the list
 799      * {@link ProteinType.AlternativeName }
 800      *
 801      *
 802      */
 803     public List<ProteinType.AlternativeName> getAlternativeName()
 804     {
 805       if (alternativeName == null)
 806       {
 807         alternativeName = new ArrayList<ProteinType.AlternativeName>();
 808       }
 809       return this.alternativeName;
 810     }
 811
 812     /**
 813      * Gets the value of the submittedName property.
 814      *
 815      * <p>
 816      * This accessor method returns a reference to the live list, not a
 817      * snapshot. Therefore any modification you make to the returned list will
 818      * be present inside the JAXB object. This is why there is not a
 819      * <CODE>set</CODE> method for the submittedName property.
 820      *
 821      * <p>
 822      * For example, to add a new item, do as follows:
 823      *
 824      * <pre>
 825      * getSubmittedName().add(newItem);
 826      * </pre>
 827      *
 828      *
 829      * <p>
 830      * Objects of the following type(s) are allowed in the list
 831      * {@link ProteinType.SubmittedName }
 832      *
 833      *
 834      */
 835     public List<ProteinType.SubmittedName> getSubmittedName()
 836     {
 837       if (submittedName == null)
 838       {
 839         submittedName = new ArrayList<ProteinType.SubmittedName>();
 840       }
 841       return this.submittedName;
 842     }
 843
 844     /**
 845      * Gets the value of the allergenName property.
 846      *
 847      * @return possible object is {@link EvidencedStringType }
 848      *
 849      */
 850     public EvidencedStringType getAllergenName()
 851     {
 852       return allergenName;
 853     }
 854
 855     /**
 856      * Sets the value of the allergenName property.
 857      *
 858      * @param value
 859      *          allowed object is {@link EvidencedStringType }
 860      *
 861      */
 862     public void setAllergenName(EvidencedStringType value)
 863     {
 864       this.allergenName = value;
 865     }
 866
 867     /**
 868      * Gets the value of the biotechName property.
 869      *
 870      * @return possible object is {@link EvidencedStringType }
 871      *
 872      */
 873     public EvidencedStringType getBiotechName()
 874     {
 875       return biotechName;
 876     }
 877
 878     /**
 879      * Sets the value of the biotechName property.
 880      *
 881      * @param value
 882      *          allowed object is {@link EvidencedStringType }
 883      *
 884      */
 885     public void setBiotechName(EvidencedStringType value)
 886     {
 887       this.biotechName = value;
 888     }
 889
 890     /**
 891      * Gets the value of the cdAntigenName property.
 892      *
 893      * <p>
 894      * This accessor method returns a reference to the live list, not a
 895      * snapshot. Therefore any modification you make to the returned list will
 896      * be present inside the JAXB object. This is why there is not a
 897      * <CODE>set</CODE> method for the cdAntigenName property.
 898      *
 899      * <p>
 900      * For example, to add a new item, do as follows:
 901      *
 902      * <pre>
 903      * getCdAntigenName().add(newItem);
 904      * </pre>
 905      *
 906      *
 907      * <p>
 908      * Objects of the following type(s) are allowed in the list
 909      * {@link EvidencedStringType }
 910      *
 911      *
 912      */
 913     public List<EvidencedStringType> getCdAntigenName()
 914     {
 915       if (cdAntigenName == null)
 916       {
 917         cdAntigenName = new ArrayList<EvidencedStringType>();
 918       }
 919       return this.cdAntigenName;
 920     }
 921
 922     /**
 923      * Gets the value of the innName property.
 924      *
 925      * <p>
 926      * This accessor method returns a reference to the live list, not a
 927      * snapshot. Therefore any modification you make to the returned list will
 928      * be present inside the JAXB object. This is why there is not a
 929      * <CODE>set</CODE> method for the innName property.
 930      *
 931      * <p>
 932      * For example, to add a new item, do as follows:
 933      *
 934      * <pre>
 935      * getInnName().add(newItem);
 936      * </pre>
 937      *
 938      *
 939      * <p>
 940      * Objects of the following type(s) are allowed in the list
 941      * {@link EvidencedStringType }
 942      *
 943      *
 944      */
 945     public List<EvidencedStringType> getInnName()
 946     {
 947       if (innName == null)
 948       {
 949         innName = new ArrayList<EvidencedStringType>();
 950       }
 951       return this.innName;
 952     }
 953
 954   }
 955
 956   /**
 957    * <p>
 958    * Java class for anonymous complex type.
 959    *
 960    * <p>
 961    * The following schema fragment specifies the expected content contained
 962    * within this class.
 963    *
 964    * <pre>
 965    * &lt;complexType>
 966    *   &lt;complexContent>
 967    *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 968    *       &lt;sequence>
 969    *         &lt;element name="fullName" type="{http://uniprot.org/uniprot}evidencedStringType"/>
 970    *         &lt;element name="shortName" type="{http://uniprot.org/uniprot}evidencedStringType" maxOccurs="unbounded" minOccurs="0"/>
 971    *         &lt;element name="ecNumber" type="{http://uniprot.org/uniprot}evidencedStringType" maxOccurs="unbounded" minOccurs="0"/>
 972    *       &lt;/sequence>
 973    *     &lt;/restriction>
 974    *   &lt;/complexContent>
 975    * &lt;/complexType>
 976    * </pre>
 977    *
 978    *
 979    */
 980   @XmlAccessorType(XmlAccessType.FIELD)
 981   @XmlType(name = "", propOrder = { "fullName", "shortName", "ecNumber" })
 982   public static class RecommendedName
 983   {
 984
 985     @XmlElement(required = true)
 986     protected EvidencedStringType fullName;
 987
 988     protected List<EvidencedStringType> shortName;
 989
 990     protected List<EvidencedStringType> ecNumber;
 991
 992     /**
 993      * Gets the value of the fullName property.
 994      *
 995      * @return possible object is {@link EvidencedStringType }
 996      *
 997      */
 998     public EvidencedStringType getFullName()
 999     {
1000       return fullName;
1001     }
1002
1003     /**
1004      * Sets the value of the fullName property.
1005      *
1006      * @param value
1007      *          allowed object is {@link EvidencedStringType }
1008      *
1009      */
1010     public void setFullName(EvidencedStringType value)
1011     {
1012       this.fullName = value;
1013     }
1014
1015     /**
1016      * Gets the value of the shortName property.
1017      *
1018      * <p>
1019      * This accessor method returns a reference to the live list, not a
1020      * snapshot. Therefore any modification you make to the returned list will
1021      * be present inside the JAXB object. This is why there is not a
1022      * <CODE>set</CODE> method for the shortName property.
1023      *
1024      * <p>
1025      * For example, to add a new item, do as follows:
1026      *
1027      * <pre>
1028      * getShortName().add(newItem);
1029      * </pre>
1030      *
1031      *
1032      * <p>
1033      * Objects of the following type(s) are allowed in the list
1034      * {@link EvidencedStringType }
1035      *
1036      *
1037      */
1038     public List<EvidencedStringType> getShortName()
1039     {
1040       if (shortName == null)
1041       {
1042         shortName = new ArrayList<EvidencedStringType>();
1043       }
1044       return this.shortName;
1045     }
1046
1047     /**
1048      * Gets the value of the ecNumber property.
1049      *
1050      * <p>
1051      * This accessor method returns a reference to the live list, not a
1052      * snapshot. Therefore any modification you make to the returned list will
1053      * be present inside the JAXB object. This is why there is not a
1054      * <CODE>set</CODE> method for the ecNumber property.
1055      *
1056      * <p>
1057      * For example, to add a new item, do as follows:
1058      *
1059      * <pre>
1060      * getEcNumber().add(newItem);
1061      * </pre>
1062      *
1063      *
1064      * <p>
1065      * Objects of the following type(s) are allowed in the list
1066      * {@link EvidencedStringType }
1067      *
1068      *
1069      */
1070     public List<EvidencedStringType> getEcNumber()
1071     {
1072       if (ecNumber == null)
1073       {
1074         ecNumber = new ArrayList<EvidencedStringType>();
1075       }
1076       return this.ecNumber;
1077     }
1078
1079   }
1080
1081   /**
1082    * <p>
1083    * Java class for anonymous complex type.
1084    *
1085    * <p>
1086    * The following schema fragment specifies the expected content contained
1087    * within this class.
1088    *
1089    * <pre>
1090    * &lt;complexType>
1091    *   &lt;complexContent>
1092    *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
1093    *       &lt;sequence>
1094    *         &lt;element name="fullName" type="{http://uniprot.org/uniprot}evidencedStringType"/>
1095    *         &lt;element name="ecNumber" type="{http://uniprot.org/uniprot}evidencedStringType" maxOccurs="unbounded" minOccurs="0"/>
1096    *       &lt;/sequence>
1097    *     &lt;/restriction>
1098    *   &lt;/complexContent>
1099    * &lt;/complexType>
1100    * </pre>
1101    *
1102    *
1103    */
1104   @XmlAccessorType(XmlAccessType.FIELD)
1105   @XmlType(name = "", propOrder = { "fullName", "ecNumber" })
1106   public static class SubmittedName
1107   {
1108
1109     @XmlElement(required = true)
1110     protected EvidencedStringType fullName;
1111
1112     protected List<EvidencedStringType> ecNumber;
1113
1114     /**
1115      * Gets the value of the fullName property.
1116      *
1117      * @return possible object is {@link EvidencedStringType }
1118      *
1119      */
1120     public EvidencedStringType getFullName()
1121     {
1122       return fullName;
1123     }
1124
1125     /**
1126      * Sets the value of the fullName property.
1127      *
1128      * @param value
1129      *          allowed object is {@link EvidencedStringType }
1130      *
1131      */
1132     public void setFullName(EvidencedStringType value)
1133     {
1134       this.fullName = value;
1135     }
1136
1137     /**
1138      * Gets the value of the ecNumber property.
1139      *
1140      * <p>
1141      * This accessor method returns a reference to the live list, not a
1142      * snapshot. Therefore any modification you make to the returned list will
1143      * be present inside the JAXB object. This is why there is not a
1144      * <CODE>set</CODE> method for the ecNumber property.
1145      *
1146      * <p>
1147      * For example, to add a new item, do as follows:
1148      *
1149      * <pre>
1150      * getEcNumber().add(newItem);
1151      * </pre>
1152      *
1153      *
1154      * <p>
1155      * Objects of the following type(s) are allowed in the list
1156      * {@link EvidencedStringType }
1157      *
1158      *
1159      */
1160     public List<EvidencedStringType> getEcNumber()
1161     {
1162       if (ecNumber == null)
1163       {
1164         ecNumber = new ArrayList<EvidencedStringType>();
1165       }
1166       return this.ecNumber;
1167     }
1168
1169   }
1170
1171 }