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