Coverage Report - ca.uhn.hl7v2.test.singledt.conf.message.ADT_A01
 
Classes in this File Line Coverage Branch Coverage Complexity
ADT_A01
25%
33/131
N/A
1.011
 
 1  
 /*
 2  
  * This class is an auto-generated source file for a HAPI
 3  
  * HL7 v2.x standard structure class.
 4  
  *
 5  
  * For more information, visit: http://hl7api.sourceforge.net/
 6  
  * 
 7  
  * The contents of this file are subject to the Mozilla Public License Version 1.1 
 8  
  * (the "License"); you may not use this file except in compliance with the License. 
 9  
  * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
 10  
  * Software distributed under the License is distributed on an "AS IS" basis, 
 11  
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 
 12  
  * specific language governing rights and limitations under the License. 
 13  
  * 
 14  
  * The Original Code is "[file_name]".  Description: 
 15  
  * "[one_line_description]" 
 16  
  * 
 17  
  * The Initial Developer of the Original Code is University Health Network. Copyright (C) 
 18  
  * 2012.  All Rights Reserved. 
 19  
  * 
 20  
  * Contributor(s): ______________________________________. 
 21  
  * 
 22  
  * Alternatively, the contents of this file may be used under the terms of the 
 23  
  * GNU General Public License (the  "GPL"), in which case the provisions of the GPL are 
 24  
  * applicable instead of those above.  If you wish to allow use of your version of this 
 25  
  * file only under the terms of the GPL and not to allow others to use your version 
 26  
  * of this file under the MPL, indicate your decision by deleting  the provisions above 
 27  
  * and replace  them with the notice and other provisions required by the GPL License.  
 28  
  * If you do not delete the provisions above, a recipient may use your version of 
 29  
  * this file under either the MPL or the GPL. 
 30  
  * 
 31  
  */
 32  
 
 33  
 
 34  
 package ca.uhn.hl7v2.test.singledt.conf.message;
 35  
 
 36  
 import ca.uhn.hl7v2.test.singledt.conf.group.*;
 37  
 import ca.uhn.hl7v2.test.singledt.conf.segment.*;
 38  
 
 39  
 import ca.uhn.hl7v2.HL7Exception;
 40  
 import ca.uhn.hl7v2.parser.ModelClassFactory;
 41  
 import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
 42  
 import ca.uhn.hl7v2.model.*;
 43  
 
 44  
 
 45  
 /**
 46  
  * <p>Represents a ADT_A01 message structure (see chapter ). This structure contains the 
 47  
  * following elements: </p>
 48  
  * <ul>
 49  
                                  * <li>1: MSH (Message Header) <b> </b> </li>
 50  
                                  * <li>2: SFT (Software Segment) <b>optional repeating</b> </li>
 51  
                                  * <li>3: EVN (Event Type) <b> </b> </li>
 52  
                                  * <li>4: PID (Patient Identification) <b> </b> </li>
 53  
                                  * <li>5: PD1 (Patient Additional Demographic) <b>optional </b> </li>
 54  
                                  * <li>6: ROL (Role) <b>optional repeating</b> </li>
 55  
                                  * <li>7: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li>
 56  
                                  * <li>8: PV1 (Patient Visit) <b> </b> </li>
 57  
                                  * <li>9: PV2 (Patient Visit - Additional Information) <b>optional </b> </li>
 58  
                                  * <li>10: ROL (Role) <b>optional repeating</b> </li>
 59  
                                  * <li>11: DB1 (Disability) <b>optional repeating</b> </li>
 60  
                                  * <li>12: OBX (Observation/Result) <b>optional repeating</b> </li>
 61  
                                  * <li>13: AL1 (Patient Allergy Information) <b>optional repeating</b> </li>
 62  
                                  * <li>14: DG1 (Diagnosis) <b>optional repeating</b> </li>
 63  
                                  * <li>15: DRG (Diagnosis Related Group) <b>optional </b> </li>
 64  
                                  * <li>16: ADT_A01_PROCEDURE (PROCEDURE) <b>optional repeating</b> </li>
 65  
                                  * <li>17: GT1 (Guarantor) <b>optional repeating</b> </li>
 66  
                                  * <li>18: ADT_A01_INSURANCE (INSURANCE) <b>optional repeating</b> </li>
 67  
                                  * <li>19: ACC (Accident) <b>optional </b> </li>
 68  
                                  * <li>20: UB1 (UB82) <b>optional </b> </li>
 69  
                                  * <li>21: UB2 (UB92 Data) <b>optional </b> </li>
 70  
                                  * <li>22: PDA (Patient Death and Autopsy) <b>optional </b> </li>
 71  
  * </ul>
 72  
  */
 73  
 //@SuppressWarnings("unused")
 74  
 public class ADT_A01 extends AbstractMessage  {
 75  
 
 76  
     /**
 77  
      * Creates a new ADT_A01 message with DefaultModelClassFactory. 
 78  
      */ 
 79  
     public ADT_A01() { 
 80  2
        this(new DefaultModelClassFactory());
 81  2
     }
 82  
 
 83  
     /** 
 84  
      * Creates a new ADT_A01 message with custom ModelClassFactory.
 85  
      */
 86  
     public ADT_A01(ModelClassFactory factory) {
 87  2
        super(factory);
 88  2
        init(factory);
 89  2
     }
 90  
 
 91  
     private void init(ModelClassFactory factory) {
 92  
        try {
 93  2
                           this.add(MSH.class, true, false);
 94  2
                                   this.add(SFT.class, false, true);
 95  2
                                   this.add(EVN.class, true, false);
 96  2
                                   this.add(PID.class, true, false);
 97  2
                                   this.add(PD1.class, false, false);
 98  2
                                   this.add(ROL.class, false, true);
 99  2
                                   this.add(NK1.class, false, true);
 100  2
                                   this.add(PV1.class, true, false);
 101  2
                                   this.add(PV2.class, false, false);
 102  2
                                   this.add(ROL.class, false, true);
 103  2
                                   this.add(DB1.class, false, true);
 104  2
                                   this.add(OBX.class, false, true);
 105  2
                                   this.add(AL1.class, false, true);
 106  2
                                   this.add(DG1.class, false, true);
 107  2
                                   this.add(DRG.class, false, false);
 108  2
                                   this.add(ADT_A01_PROCEDURE.class, false, true);
 109  2
                                   this.add(GT1.class, false, true);
 110  2
                                   this.add(ADT_A01_INSURANCE.class, false, true);
 111  2
                                   this.add(ACC.class, false, false);
 112  2
                                   this.add(UB1.class, false, false);
 113  2
                                   this.add(UB2.class, false, false);
 114  2
                                   this.add(PDA.class, false, false);
 115  0
                } catch(HL7Exception e) {
 116  0
           log.error("Unexpected error creating ADT_A01 - this is probably a bug in the source code generator.", e);
 117  2
        }
 118  2
     }
 119  
 
 120  
 
 121  
     /** 
 122  
      * Returns "2.5"
 123  
      */
 124  
     public String getVersion() {
 125  2
        return "2.5";
 126  
     }
 127  
 
 128  
 
 129  
 
 130  
 
 131  
     /**
 132  
      * <p>
 133  
      * Returns
 134  
      * MSH (Message Header) - creates it if necessary
 135  
      * </p>
 136  
      * 
 137  
      *
 138  
      */
 139  
     public MSH getMSH() { 
 140  0
        return getTyped("MSH", MSH.class);
 141  
     }
 142  
 
 143  
 
 144  
 
 145  
 
 146  
 
 147  
     /**
 148  
      * <p>
 149  
      * Returns
 150  
      * the first repetition of 
 151  
      * SFT (Software Segment) - creates it if necessary
 152  
      * </p>
 153  
      * 
 154  
      *
 155  
      */
 156  
     public SFT getSFT() { 
 157  0
        return getTyped("SFT", SFT.class);
 158  
     }
 159  
 
 160  
 
 161  
     /**
 162  
      * <p>
 163  
      * Returns a specific repetition of
 164  
      * SFT (Software Segment) - creates it if necessary
 165  
      * </p>
 166  
      * 
 167  
      *
 168  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 169  
      * @throws HL7Exception if the repetition requested is more than one 
 170  
      *     greater than the number of existing repetitions.
 171  
      */
 172  
     public SFT getSFT(int rep) { 
 173  0
        return getTyped("SFT", rep, SFT.class);
 174  
     }
 175  
 
 176  
     /** 
 177  
      * <p>
 178  
      * Returns the number of existing repetitions of SFT 
 179  
      * </p>
 180  
      * 
 181  
      */ 
 182  
     public int getSFTReps() { 
 183  0
             return getReps("SFT");
 184  
     } 
 185  
 
 186  
     /** 
 187  
      * <p>
 188  
      * Returns a non-modifiable List containing all current existing repetitions of SFT.
 189  
      * <p>
 190  
      * <p>
 191  
      * Note that unlike {@link #getSFT()}, this method will not create any reps
 192  
      * if none are already present, so an empty list may be returned.
 193  
      * </p>
 194  
      * 
 195  
      */ 
 196  
     public java.util.List<SFT> getSFTAll() throws HL7Exception {
 197  0
             return getAllAsList("SFT", SFT.class);
 198  
     } 
 199  
 
 200  
     /**
 201  
      * <p>
 202  
      * Inserts a specific repetition of SFT (Software Segment)
 203  
      * </p>
 204  
      * 
 205  
      *
 206  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 207  
      */
 208  
     public void insertSFT(SFT structure, int rep) throws HL7Exception { 
 209  0
        super.insertRepetition( "SFT", structure, rep);
 210  0
     }
 211  
 
 212  
 
 213  
     /**
 214  
      * <p>
 215  
      * Inserts a specific repetition of SFT (Software Segment)
 216  
      * </p>
 217  
      * 
 218  
      *
 219  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 220  
      */
 221  
     public SFT insertSFT(int rep) throws HL7Exception { 
 222  0
        return (SFT)super.insertRepetition("SFT", rep);
 223  
     }
 224  
 
 225  
 
 226  
     /**
 227  
      * <p>
 228  
      * Removes a specific repetition of SFT (Software Segment)
 229  
      * </p>
 230  
      * 
 231  
      *
 232  
      * @see AbstractGroup#removeRepetition(String, int) 
 233  
      */
 234  
     public SFT removeSFT(int rep) throws HL7Exception { 
 235  0
        return (SFT)super.removeRepetition("SFT", rep);
 236  
     }
 237  
 
 238  
 
 239  
 
 240  
 
 241  
     /**
 242  
      * <p>
 243  
      * Returns
 244  
      * EVN (Event Type) - creates it if necessary
 245  
      * </p>
 246  
      * 
 247  
      *
 248  
      */
 249  
     public EVN getEVN() { 
 250  0
        return getTyped("EVN", EVN.class);
 251  
     }
 252  
 
 253  
 
 254  
 
 255  
 
 256  
 
 257  
     /**
 258  
      * <p>
 259  
      * Returns
 260  
      * PID (Patient Identification) - creates it if necessary
 261  
      * </p>
 262  
      * 
 263  
      *
 264  
      */
 265  
     public PID getPID() { 
 266  0
        return getTyped("PID", PID.class);
 267  
     }
 268  
 
 269  
 
 270  
 
 271  
 
 272  
 
 273  
     /**
 274  
      * <p>
 275  
      * Returns
 276  
      * PD1 (Patient Additional Demographic) - creates it if necessary
 277  
      * </p>
 278  
      * 
 279  
      *
 280  
      */
 281  
     public PD1 getPD1() { 
 282  0
        return getTyped("PD1", PD1.class);
 283  
     }
 284  
 
 285  
 
 286  
 
 287  
 
 288  
 
 289  
     /**
 290  
      * <p>
 291  
      * Returns
 292  
      * the first repetition of 
 293  
      * ROL (Role) - creates it if necessary
 294  
      * </p>
 295  
      * 
 296  
      *
 297  
      */
 298  
     public ROL getROL() { 
 299  0
        return getTyped("ROL", ROL.class);
 300  
     }
 301  
 
 302  
 
 303  
     /**
 304  
      * <p>
 305  
      * Returns a specific repetition of
 306  
      * ROL (Role) - creates it if necessary
 307  
      * </p>
 308  
      * 
 309  
      *
 310  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 311  
      * @throws HL7Exception if the repetition requested is more than one 
 312  
      *     greater than the number of existing repetitions.
 313  
      */
 314  
     public ROL getROL(int rep) { 
 315  0
        return getTyped("ROL", rep, ROL.class);
 316  
     }
 317  
 
 318  
     /** 
 319  
      * <p>
 320  
      * Returns the number of existing repetitions of ROL 
 321  
      * </p>
 322  
      * 
 323  
      */ 
 324  
     public int getROLReps() { 
 325  0
             return getReps("ROL");
 326  
     } 
 327  
 
 328  
     /** 
 329  
      * <p>
 330  
      * Returns a non-modifiable List containing all current existing repetitions of ROL.
 331  
      * <p>
 332  
      * <p>
 333  
      * Note that unlike {@link #getROL()}, this method will not create any reps
 334  
      * if none are already present, so an empty list may be returned.
 335  
      * </p>
 336  
      * 
 337  
      */ 
 338  
     public java.util.List<ROL> getROLAll() throws HL7Exception {
 339  0
             return getAllAsList("ROL", ROL.class);
 340  
     } 
 341  
 
 342  
     /**
 343  
      * <p>
 344  
      * Inserts a specific repetition of ROL (Role)
 345  
      * </p>
 346  
      * 
 347  
      *
 348  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 349  
      */
 350  
     public void insertROL(ROL structure, int rep) throws HL7Exception { 
 351  0
        super.insertRepetition( "ROL", structure, rep);
 352  0
     }
 353  
 
 354  
 
 355  
     /**
 356  
      * <p>
 357  
      * Inserts a specific repetition of ROL (Role)
 358  
      * </p>
 359  
      * 
 360  
      *
 361  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 362  
      */
 363  
     public ROL insertROL(int rep) throws HL7Exception { 
 364  0
        return (ROL)super.insertRepetition("ROL", rep);
 365  
     }
 366  
 
 367  
 
 368  
     /**
 369  
      * <p>
 370  
      * Removes a specific repetition of ROL (Role)
 371  
      * </p>
 372  
      * 
 373  
      *
 374  
      * @see AbstractGroup#removeRepetition(String, int) 
 375  
      */
 376  
     public ROL removeROL(int rep) throws HL7Exception { 
 377  0
        return (ROL)super.removeRepetition("ROL", rep);
 378  
     }
 379  
 
 380  
 
 381  
 
 382  
 
 383  
     /**
 384  
      * <p>
 385  
      * Returns
 386  
      * the first repetition of 
 387  
      * NK1 (Next of Kin / Associated Parties) - creates it if necessary
 388  
      * </p>
 389  
      * 
 390  
      *
 391  
      */
 392  
     public NK1 getNK1() { 
 393  0
        return getTyped("NK1", NK1.class);
 394  
     }
 395  
 
 396  
 
 397  
     /**
 398  
      * <p>
 399  
      * Returns a specific repetition of
 400  
      * NK1 (Next of Kin / Associated Parties) - creates it if necessary
 401  
      * </p>
 402  
      * 
 403  
      *
 404  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 405  
      * @throws HL7Exception if the repetition requested is more than one 
 406  
      *     greater than the number of existing repetitions.
 407  
      */
 408  
     public NK1 getNK1(int rep) { 
 409  0
        return getTyped("NK1", rep, NK1.class);
 410  
     }
 411  
 
 412  
     /** 
 413  
      * <p>
 414  
      * Returns the number of existing repetitions of NK1 
 415  
      * </p>
 416  
      * 
 417  
      */ 
 418  
     public int getNK1Reps() { 
 419  0
             return getReps("NK1");
 420  
     } 
 421  
 
 422  
     /** 
 423  
      * <p>
 424  
      * Returns a non-modifiable List containing all current existing repetitions of NK1.
 425  
      * <p>
 426  
      * <p>
 427  
      * Note that unlike {@link #getNK1()}, this method will not create any reps
 428  
      * if none are already present, so an empty list may be returned.
 429  
      * </p>
 430  
      * 
 431  
      */ 
 432  
     public java.util.List<NK1> getNK1All() throws HL7Exception {
 433  0
             return getAllAsList("NK1", NK1.class);
 434  
     } 
 435  
 
 436  
     /**
 437  
      * <p>
 438  
      * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
 439  
      * </p>
 440  
      * 
 441  
      *
 442  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 443  
      */
 444  
     public void insertNK1(NK1 structure, int rep) throws HL7Exception { 
 445  0
        super.insertRepetition( "NK1", structure, rep);
 446  0
     }
 447  
 
 448  
 
 449  
     /**
 450  
      * <p>
 451  
      * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
 452  
      * </p>
 453  
      * 
 454  
      *
 455  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 456  
      */
 457  
     public NK1 insertNK1(int rep) throws HL7Exception { 
 458  0
        return (NK1)super.insertRepetition("NK1", rep);
 459  
     }
 460  
 
 461  
 
 462  
     /**
 463  
      * <p>
 464  
      * Removes a specific repetition of NK1 (Next of Kin / Associated Parties)
 465  
      * </p>
 466  
      * 
 467  
      *
 468  
      * @see AbstractGroup#removeRepetition(String, int) 
 469  
      */
 470  
     public NK1 removeNK1(int rep) throws HL7Exception { 
 471  0
        return (NK1)super.removeRepetition("NK1", rep);
 472  
     }
 473  
 
 474  
 
 475  
 
 476  
 
 477  
     /**
 478  
      * <p>
 479  
      * Returns
 480  
      * PV1 (Patient Visit) - creates it if necessary
 481  
      * </p>
 482  
      * 
 483  
      *
 484  
      */
 485  
     public PV1 getPV1() { 
 486  0
        return getTyped("PV1", PV1.class);
 487  
     }
 488  
 
 489  
 
 490  
 
 491  
 
 492  
 
 493  
     /**
 494  
      * <p>
 495  
      * Returns
 496  
      * PV2 (Patient Visit - Additional Information) - creates it if necessary
 497  
      * </p>
 498  
      * 
 499  
      *
 500  
      */
 501  
     public PV2 getPV2() { 
 502  0
        return getTyped("PV2", PV2.class);
 503  
     }
 504  
 
 505  
 
 506  
 
 507  
 
 508  
 
 509  
     /**
 510  
      * <p>
 511  
      * Returns
 512  
      * the first repetition of 
 513  
      * ROL2 (Role) - creates it if necessary
 514  
      * </p>
 515  
      * 
 516  
      *
 517  
      */
 518  
     public ROL getROL2() { 
 519  0
        return getTyped("ROL2", ROL.class);
 520  
     }
 521  
 
 522  
 
 523  
     /**
 524  
      * <p>
 525  
      * Returns a specific repetition of
 526  
      * ROL2 (Role) - creates it if necessary
 527  
      * </p>
 528  
      * 
 529  
      *
 530  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 531  
      * @throws HL7Exception if the repetition requested is more than one 
 532  
      *     greater than the number of existing repetitions.
 533  
      */
 534  
     public ROL getROL2(int rep) { 
 535  0
        return getTyped("ROL2", rep, ROL.class);
 536  
     }
 537  
 
 538  
     /** 
 539  
      * <p>
 540  
      * Returns the number of existing repetitions of ROL2 
 541  
      * </p>
 542  
      * 
 543  
      */ 
 544  
     public int getROL2Reps() { 
 545  0
             return getReps("ROL2");
 546  
     } 
 547  
 
 548  
     /** 
 549  
      * <p>
 550  
      * Returns a non-modifiable List containing all current existing repetitions of ROL2.
 551  
      * <p>
 552  
      * <p>
 553  
      * Note that unlike {@link #getROL2()}, this method will not create any reps
 554  
      * if none are already present, so an empty list may be returned.
 555  
      * </p>
 556  
      * 
 557  
      */ 
 558  
     public java.util.List<ROL> getROL2All() throws HL7Exception {
 559  0
             return getAllAsList("ROL2", ROL.class);
 560  
     } 
 561  
 
 562  
     /**
 563  
      * <p>
 564  
      * Inserts a specific repetition of ROL2 (Role)
 565  
      * </p>
 566  
      * 
 567  
      *
 568  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 569  
      */
 570  
     public void insertROL2(ROL structure, int rep) throws HL7Exception { 
 571  0
        super.insertRepetition( "ROL2", structure, rep);
 572  0
     }
 573  
 
 574  
 
 575  
     /**
 576  
      * <p>
 577  
      * Inserts a specific repetition of ROL2 (Role)
 578  
      * </p>
 579  
      * 
 580  
      *
 581  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 582  
      */
 583  
     public ROL insertROL2(int rep) throws HL7Exception { 
 584  0
        return (ROL)super.insertRepetition("ROL2", rep);
 585  
     }
 586  
 
 587  
 
 588  
     /**
 589  
      * <p>
 590  
      * Removes a specific repetition of ROL2 (Role)
 591  
      * </p>
 592  
      * 
 593  
      *
 594  
      * @see AbstractGroup#removeRepetition(String, int) 
 595  
      */
 596  
     public ROL removeROL2(int rep) throws HL7Exception { 
 597  0
        return (ROL)super.removeRepetition("ROL2", rep);
 598  
     }
 599  
 
 600  
 
 601  
 
 602  
 
 603  
     /**
 604  
      * <p>
 605  
      * Returns
 606  
      * the first repetition of 
 607  
      * DB1 (Disability) - creates it if necessary
 608  
      * </p>
 609  
      * 
 610  
      *
 611  
      */
 612  
     public DB1 getDB1() { 
 613  1
        return getTyped("DB1", DB1.class);
 614  
     }
 615  
 
 616  
 
 617  
     /**
 618  
      * <p>
 619  
      * Returns a specific repetition of
 620  
      * DB1 (Disability) - creates it if necessary
 621  
      * </p>
 622  
      * 
 623  
      *
 624  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 625  
      * @throws HL7Exception if the repetition requested is more than one 
 626  
      *     greater than the number of existing repetitions.
 627  
      */
 628  
     public DB1 getDB1(int rep) { 
 629  0
        return getTyped("DB1", rep, DB1.class);
 630  
     }
 631  
 
 632  
     /** 
 633  
      * <p>
 634  
      * Returns the number of existing repetitions of DB1 
 635  
      * </p>
 636  
      * 
 637  
      */ 
 638  
     public int getDB1Reps() { 
 639  0
             return getReps("DB1");
 640  
     } 
 641  
 
 642  
     /** 
 643  
      * <p>
 644  
      * Returns a non-modifiable List containing all current existing repetitions of DB1.
 645  
      * <p>
 646  
      * <p>
 647  
      * Note that unlike {@link #getDB1()}, this method will not create any reps
 648  
      * if none are already present, so an empty list may be returned.
 649  
      * </p>
 650  
      * 
 651  
      */ 
 652  
     public java.util.List<DB1> getDB1All() throws HL7Exception {
 653  0
             return getAllAsList("DB1", DB1.class);
 654  
     } 
 655  
 
 656  
     /**
 657  
      * <p>
 658  
      * Inserts a specific repetition of DB1 (Disability)
 659  
      * </p>
 660  
      * 
 661  
      *
 662  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 663  
      */
 664  
     public void insertDB1(DB1 structure, int rep) throws HL7Exception { 
 665  0
        super.insertRepetition( "DB1", structure, rep);
 666  0
     }
 667  
 
 668  
 
 669  
     /**
 670  
      * <p>
 671  
      * Inserts a specific repetition of DB1 (Disability)
 672  
      * </p>
 673  
      * 
 674  
      *
 675  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 676  
      */
 677  
     public DB1 insertDB1(int rep) throws HL7Exception { 
 678  0
        return (DB1)super.insertRepetition("DB1", rep);
 679  
     }
 680  
 
 681  
 
 682  
     /**
 683  
      * <p>
 684  
      * Removes a specific repetition of DB1 (Disability)
 685  
      * </p>
 686  
      * 
 687  
      *
 688  
      * @see AbstractGroup#removeRepetition(String, int) 
 689  
      */
 690  
     public DB1 removeDB1(int rep) throws HL7Exception { 
 691  0
        return (DB1)super.removeRepetition("DB1", rep);
 692  
     }
 693  
 
 694  
 
 695  
 
 696  
 
 697  
     /**
 698  
      * <p>
 699  
      * Returns
 700  
      * the first repetition of 
 701  
      * OBX (Observation/Result) - creates it if necessary
 702  
      * </p>
 703  
      * 
 704  
      *
 705  
      */
 706  
     public OBX getOBX() { 
 707  0
        return getTyped("OBX", OBX.class);
 708  
     }
 709  
 
 710  
 
 711  
     /**
 712  
      * <p>
 713  
      * Returns a specific repetition of
 714  
      * OBX (Observation/Result) - creates it if necessary
 715  
      * </p>
 716  
      * 
 717  
      *
 718  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 719  
      * @throws HL7Exception if the repetition requested is more than one 
 720  
      *     greater than the number of existing repetitions.
 721  
      */
 722  
     public OBX getOBX(int rep) { 
 723  2
        return getTyped("OBX", rep, OBX.class);
 724  
     }
 725  
 
 726  
     /** 
 727  
      * <p>
 728  
      * Returns the number of existing repetitions of OBX 
 729  
      * </p>
 730  
      * 
 731  
      */ 
 732  
     public int getOBXReps() { 
 733  0
             return getReps("OBX");
 734  
     } 
 735  
 
 736  
     /** 
 737  
      * <p>
 738  
      * Returns a non-modifiable List containing all current existing repetitions of OBX.
 739  
      * <p>
 740  
      * <p>
 741  
      * Note that unlike {@link #getOBX()}, this method will not create any reps
 742  
      * if none are already present, so an empty list may be returned.
 743  
      * </p>
 744  
      * 
 745  
      */ 
 746  
     public java.util.List<OBX> getOBXAll() throws HL7Exception {
 747  1
             return getAllAsList("OBX", OBX.class);
 748  
     } 
 749  
 
 750  
     /**
 751  
      * <p>
 752  
      * Inserts a specific repetition of OBX (Observation/Result)
 753  
      * </p>
 754  
      * 
 755  
      *
 756  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 757  
      */
 758  
     public void insertOBX(OBX structure, int rep) throws HL7Exception { 
 759  0
        super.insertRepetition( "OBX", structure, rep);
 760  0
     }
 761  
 
 762  
 
 763  
     /**
 764  
      * <p>
 765  
      * Inserts a specific repetition of OBX (Observation/Result)
 766  
      * </p>
 767  
      * 
 768  
      *
 769  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 770  
      */
 771  
     public OBX insertOBX(int rep) throws HL7Exception { 
 772  0
        return (OBX)super.insertRepetition("OBX", rep);
 773  
     }
 774  
 
 775  
 
 776  
     /**
 777  
      * <p>
 778  
      * Removes a specific repetition of OBX (Observation/Result)
 779  
      * </p>
 780  
      * 
 781  
      *
 782  
      * @see AbstractGroup#removeRepetition(String, int) 
 783  
      */
 784  
     public OBX removeOBX(int rep) throws HL7Exception { 
 785  0
        return (OBX)super.removeRepetition("OBX", rep);
 786  
     }
 787  
 
 788  
 
 789  
 
 790  
 
 791  
     /**
 792  
      * <p>
 793  
      * Returns
 794  
      * the first repetition of 
 795  
      * AL1 (Patient Allergy Information) - creates it if necessary
 796  
      * </p>
 797  
      * 
 798  
      *
 799  
      */
 800  
     public AL1 getAL1() { 
 801  0
        return getTyped("AL1", AL1.class);
 802  
     }
 803  
 
 804  
 
 805  
     /**
 806  
      * <p>
 807  
      * Returns a specific repetition of
 808  
      * AL1 (Patient Allergy Information) - creates it if necessary
 809  
      * </p>
 810  
      * 
 811  
      *
 812  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 813  
      * @throws HL7Exception if the repetition requested is more than one 
 814  
      *     greater than the number of existing repetitions.
 815  
      */
 816  
     public AL1 getAL1(int rep) { 
 817  0
        return getTyped("AL1", rep, AL1.class);
 818  
     }
 819  
 
 820  
     /** 
 821  
      * <p>
 822  
      * Returns the number of existing repetitions of AL1 
 823  
      * </p>
 824  
      * 
 825  
      */ 
 826  
     public int getAL1Reps() { 
 827  0
             return getReps("AL1");
 828  
     } 
 829  
 
 830  
     /** 
 831  
      * <p>
 832  
      * Returns a non-modifiable List containing all current existing repetitions of AL1.
 833  
      * <p>
 834  
      * <p>
 835  
      * Note that unlike {@link #getAL1()}, this method will not create any reps
 836  
      * if none are already present, so an empty list may be returned.
 837  
      * </p>
 838  
      * 
 839  
      */ 
 840  
     public java.util.List<AL1> getAL1All() throws HL7Exception {
 841  0
             return getAllAsList("AL1", AL1.class);
 842  
     } 
 843  
 
 844  
     /**
 845  
      * <p>
 846  
      * Inserts a specific repetition of AL1 (Patient Allergy Information)
 847  
      * </p>
 848  
      * 
 849  
      *
 850  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 851  
      */
 852  
     public void insertAL1(AL1 structure, int rep) throws HL7Exception { 
 853  0
        super.insertRepetition( "AL1", structure, rep);
 854  0
     }
 855  
 
 856  
 
 857  
     /**
 858  
      * <p>
 859  
      * Inserts a specific repetition of AL1 (Patient Allergy Information)
 860  
      * </p>
 861  
      * 
 862  
      *
 863  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 864  
      */
 865  
     public AL1 insertAL1(int rep) throws HL7Exception { 
 866  0
        return (AL1)super.insertRepetition("AL1", rep);
 867  
     }
 868  
 
 869  
 
 870  
     /**
 871  
      * <p>
 872  
      * Removes a specific repetition of AL1 (Patient Allergy Information)
 873  
      * </p>
 874  
      * 
 875  
      *
 876  
      * @see AbstractGroup#removeRepetition(String, int) 
 877  
      */
 878  
     public AL1 removeAL1(int rep) throws HL7Exception { 
 879  0
        return (AL1)super.removeRepetition("AL1", rep);
 880  
     }
 881  
 
 882  
 
 883  
 
 884  
 
 885  
     /**
 886  
      * <p>
 887  
      * Returns
 888  
      * the first repetition of 
 889  
      * DG1 (Diagnosis) - creates it if necessary
 890  
      * </p>
 891  
      * 
 892  
      *
 893  
      */
 894  
     public DG1 getDG1() { 
 895  0
        return getTyped("DG1", DG1.class);
 896  
     }
 897  
 
 898  
 
 899  
     /**
 900  
      * <p>
 901  
      * Returns a specific repetition of
 902  
      * DG1 (Diagnosis) - creates it if necessary
 903  
      * </p>
 904  
      * 
 905  
      *
 906  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 907  
      * @throws HL7Exception if the repetition requested is more than one 
 908  
      *     greater than the number of existing repetitions.
 909  
      */
 910  
     public DG1 getDG1(int rep) { 
 911  0
        return getTyped("DG1", rep, DG1.class);
 912  
     }
 913  
 
 914  
     /** 
 915  
      * <p>
 916  
      * Returns the number of existing repetitions of DG1 
 917  
      * </p>
 918  
      * 
 919  
      */ 
 920  
     public int getDG1Reps() { 
 921  0
             return getReps("DG1");
 922  
     } 
 923  
 
 924  
     /** 
 925  
      * <p>
 926  
      * Returns a non-modifiable List containing all current existing repetitions of DG1.
 927  
      * <p>
 928  
      * <p>
 929  
      * Note that unlike {@link #getDG1()}, this method will not create any reps
 930  
      * if none are already present, so an empty list may be returned.
 931  
      * </p>
 932  
      * 
 933  
      */ 
 934  
     public java.util.List<DG1> getDG1All() throws HL7Exception {
 935  0
             return getAllAsList("DG1", DG1.class);
 936  
     } 
 937  
 
 938  
     /**
 939  
      * <p>
 940  
      * Inserts a specific repetition of DG1 (Diagnosis)
 941  
      * </p>
 942  
      * 
 943  
      *
 944  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 945  
      */
 946  
     public void insertDG1(DG1 structure, int rep) throws HL7Exception { 
 947  0
        super.insertRepetition( "DG1", structure, rep);
 948  0
     }
 949  
 
 950  
 
 951  
     /**
 952  
      * <p>
 953  
      * Inserts a specific repetition of DG1 (Diagnosis)
 954  
      * </p>
 955  
      * 
 956  
      *
 957  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 958  
      */
 959  
     public DG1 insertDG1(int rep) throws HL7Exception { 
 960  0
        return (DG1)super.insertRepetition("DG1", rep);
 961  
     }
 962  
 
 963  
 
 964  
     /**
 965  
      * <p>
 966  
      * Removes a specific repetition of DG1 (Diagnosis)
 967  
      * </p>
 968  
      * 
 969  
      *
 970  
      * @see AbstractGroup#removeRepetition(String, int) 
 971  
      */
 972  
     public DG1 removeDG1(int rep) throws HL7Exception { 
 973  0
        return (DG1)super.removeRepetition("DG1", rep);
 974  
     }
 975  
 
 976  
 
 977  
 
 978  
 
 979  
     /**
 980  
      * <p>
 981  
      * Returns
 982  
      * DRG (Diagnosis Related Group) - creates it if necessary
 983  
      * </p>
 984  
      * 
 985  
      *
 986  
      */
 987  
     public DRG getDRG() { 
 988  0
        return getTyped("DRG", DRG.class);
 989  
     }
 990  
 
 991  
 
 992  
 
 993  
 
 994  
 
 995  
     /**
 996  
      * <p>
 997  
      * Returns
 998  
      * the first repetition of 
 999  
      * PROCEDURE (PROCEDURE) - creates it if necessary
 1000  
      * </p>
 1001  
      * 
 1002  
      *
 1003  
      */
 1004  
     public ADT_A01_PROCEDURE getPROCEDURE() { 
 1005  0
        return getTyped("PROCEDURE", ADT_A01_PROCEDURE.class);
 1006  
     }
 1007  
 
 1008  
 
 1009  
     /**
 1010  
      * <p>
 1011  
      * Returns a specific repetition of
 1012  
      * PROCEDURE (PROCEDURE) - creates it if necessary
 1013  
      * </p>
 1014  
      * 
 1015  
      *
 1016  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 1017  
      * @throws HL7Exception if the repetition requested is more than one 
 1018  
      *     greater than the number of existing repetitions.
 1019  
      */
 1020  
     public ADT_A01_PROCEDURE getPROCEDURE(int rep) { 
 1021  0
        return getTyped("PROCEDURE", rep, ADT_A01_PROCEDURE.class);
 1022  
     }
 1023  
 
 1024  
     /** 
 1025  
      * <p>
 1026  
      * Returns the number of existing repetitions of PROCEDURE 
 1027  
      * </p>
 1028  
      * 
 1029  
      */ 
 1030  
     public int getPROCEDUREReps() { 
 1031  0
             return getReps("PROCEDURE");
 1032  
     } 
 1033  
 
 1034  
     /** 
 1035  
      * <p>
 1036  
      * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE.
 1037  
      * <p>
 1038  
      * <p>
 1039  
      * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps
 1040  
      * if none are already present, so an empty list may be returned.
 1041  
      * </p>
 1042  
      * 
 1043  
      */ 
 1044  
     public java.util.List<ADT_A01_PROCEDURE> getPROCEDUREAll() throws HL7Exception {
 1045  0
             return getAllAsList("PROCEDURE", ADT_A01_PROCEDURE.class);
 1046  
     } 
 1047  
 
 1048  
     /**
 1049  
      * <p>
 1050  
      * Inserts a specific repetition of PROCEDURE (PROCEDURE)
 1051  
      * </p>
 1052  
      * 
 1053  
      *
 1054  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 1055  
      */
 1056  
     public void insertPROCEDURE(ADT_A01_PROCEDURE structure, int rep) throws HL7Exception { 
 1057  0
        super.insertRepetition( "PROCEDURE", structure, rep);
 1058  0
     }
 1059  
 
 1060  
 
 1061  
     /**
 1062  
      * <p>
 1063  
      * Inserts a specific repetition of PROCEDURE (PROCEDURE)
 1064  
      * </p>
 1065  
      * 
 1066  
      *
 1067  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 1068  
      */
 1069  
     public ADT_A01_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 
 1070  0
        return (ADT_A01_PROCEDURE)super.insertRepetition("PROCEDURE", rep);
 1071  
     }
 1072  
 
 1073  
 
 1074  
     /**
 1075  
      * <p>
 1076  
      * Removes a specific repetition of PROCEDURE (PROCEDURE)
 1077  
      * </p>
 1078  
      * 
 1079  
      *
 1080  
      * @see AbstractGroup#removeRepetition(String, int) 
 1081  
      */
 1082  
     public ADT_A01_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 
 1083  0
        return (ADT_A01_PROCEDURE)super.removeRepetition("PROCEDURE", rep);
 1084  
     }
 1085  
 
 1086  
 
 1087  
 
 1088  
 
 1089  
     /**
 1090  
      * <p>
 1091  
      * Returns
 1092  
      * the first repetition of 
 1093  
      * GT1 (Guarantor) - creates it if necessary
 1094  
      * </p>
 1095  
      * 
 1096  
      *
 1097  
      */
 1098  
     public GT1 getGT1() { 
 1099  0
        return getTyped("GT1", GT1.class);
 1100  
     }
 1101  
 
 1102  
 
 1103  
     /**
 1104  
      * <p>
 1105  
      * Returns a specific repetition of
 1106  
      * GT1 (Guarantor) - creates it if necessary
 1107  
      * </p>
 1108  
      * 
 1109  
      *
 1110  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 1111  
      * @throws HL7Exception if the repetition requested is more than one 
 1112  
      *     greater than the number of existing repetitions.
 1113  
      */
 1114  
     public GT1 getGT1(int rep) { 
 1115  0
        return getTyped("GT1", rep, GT1.class);
 1116  
     }
 1117  
 
 1118  
     /** 
 1119  
      * <p>
 1120  
      * Returns the number of existing repetitions of GT1 
 1121  
      * </p>
 1122  
      * 
 1123  
      */ 
 1124  
     public int getGT1Reps() { 
 1125  0
             return getReps("GT1");
 1126  
     } 
 1127  
 
 1128  
     /** 
 1129  
      * <p>
 1130  
      * Returns a non-modifiable List containing all current existing repetitions of GT1.
 1131  
      * <p>
 1132  
      * <p>
 1133  
      * Note that unlike {@link #getGT1()}, this method will not create any reps
 1134  
      * if none are already present, so an empty list may be returned.
 1135  
      * </p>
 1136  
      * 
 1137  
      */ 
 1138  
     public java.util.List<GT1> getGT1All() throws HL7Exception {
 1139  0
             return getAllAsList("GT1", GT1.class);
 1140  
     } 
 1141  
 
 1142  
     /**
 1143  
      * <p>
 1144  
      * Inserts a specific repetition of GT1 (Guarantor)
 1145  
      * </p>
 1146  
      * 
 1147  
      *
 1148  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 1149  
      */
 1150  
     public void insertGT1(GT1 structure, int rep) throws HL7Exception { 
 1151  0
        super.insertRepetition( "GT1", structure, rep);
 1152  0
     }
 1153  
 
 1154  
 
 1155  
     /**
 1156  
      * <p>
 1157  
      * Inserts a specific repetition of GT1 (Guarantor)
 1158  
      * </p>
 1159  
      * 
 1160  
      *
 1161  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 1162  
      */
 1163  
     public GT1 insertGT1(int rep) throws HL7Exception { 
 1164  0
        return (GT1)super.insertRepetition("GT1", rep);
 1165  
     }
 1166  
 
 1167  
 
 1168  
     /**
 1169  
      * <p>
 1170  
      * Removes a specific repetition of GT1 (Guarantor)
 1171  
      * </p>
 1172  
      * 
 1173  
      *
 1174  
      * @see AbstractGroup#removeRepetition(String, int) 
 1175  
      */
 1176  
     public GT1 removeGT1(int rep) throws HL7Exception { 
 1177  0
        return (GT1)super.removeRepetition("GT1", rep);
 1178  
     }
 1179  
 
 1180  
 
 1181  
 
 1182  
 
 1183  
     /**
 1184  
      * <p>
 1185  
      * Returns
 1186  
      * the first repetition of 
 1187  
      * INSURANCE (INSURANCE) - creates it if necessary
 1188  
      * </p>
 1189  
      * 
 1190  
      *
 1191  
      */
 1192  
     public ADT_A01_INSURANCE getINSURANCE() { 
 1193  0
        return getTyped("INSURANCE", ADT_A01_INSURANCE.class);
 1194  
     }
 1195  
 
 1196  
 
 1197  
     /**
 1198  
      * <p>
 1199  
      * Returns a specific repetition of
 1200  
      * INSURANCE (INSURANCE) - creates it if necessary
 1201  
      * </p>
 1202  
      * 
 1203  
      *
 1204  
      * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
 1205  
      * @throws HL7Exception if the repetition requested is more than one 
 1206  
      *     greater than the number of existing repetitions.
 1207  
      */
 1208  
     public ADT_A01_INSURANCE getINSURANCE(int rep) { 
 1209  0
        return getTyped("INSURANCE", rep, ADT_A01_INSURANCE.class);
 1210  
     }
 1211  
 
 1212  
     /** 
 1213  
      * <p>
 1214  
      * Returns the number of existing repetitions of INSURANCE 
 1215  
      * </p>
 1216  
      * 
 1217  
      */ 
 1218  
     public int getINSURANCEReps() { 
 1219  0
             return getReps("INSURANCE");
 1220  
     } 
 1221  
 
 1222  
     /** 
 1223  
      * <p>
 1224  
      * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
 1225  
      * <p>
 1226  
      * <p>
 1227  
      * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
 1228  
      * if none are already present, so an empty list may be returned.
 1229  
      * </p>
 1230  
      * 
 1231  
      */ 
 1232  
     public java.util.List<ADT_A01_INSURANCE> getINSURANCEAll() throws HL7Exception {
 1233  0
             return getAllAsList("INSURANCE", ADT_A01_INSURANCE.class);
 1234  
     } 
 1235  
 
 1236  
     /**
 1237  
      * <p>
 1238  
      * Inserts a specific repetition of INSURANCE (INSURANCE)
 1239  
      * </p>
 1240  
      * 
 1241  
      *
 1242  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 1243  
      */
 1244  
     public void insertINSURANCE(ADT_A01_INSURANCE structure, int rep) throws HL7Exception { 
 1245  0
        super.insertRepetition( "INSURANCE", structure, rep);
 1246  0
     }
 1247  
 
 1248  
 
 1249  
     /**
 1250  
      * <p>
 1251  
      * Inserts a specific repetition of INSURANCE (INSURANCE)
 1252  
      * </p>
 1253  
      * 
 1254  
      *
 1255  
      * @see AbstractGroup#insertRepetition(Structure, int) 
 1256  
      */
 1257  
     public ADT_A01_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 
 1258  0
        return (ADT_A01_INSURANCE)super.insertRepetition("INSURANCE", rep);
 1259  
     }
 1260  
 
 1261  
 
 1262  
     /**
 1263  
      * <p>
 1264  
      * Removes a specific repetition of INSURANCE (INSURANCE)
 1265  
      * </p>
 1266  
      * 
 1267  
      *
 1268  
      * @see AbstractGroup#removeRepetition(String, int) 
 1269  
      */
 1270  
     public ADT_A01_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 
 1271  0
        return (ADT_A01_INSURANCE)super.removeRepetition("INSURANCE", rep);
 1272  
     }
 1273  
 
 1274  
 
 1275  
 
 1276  
 
 1277  
     /**
 1278  
      * <p>
 1279  
      * Returns
 1280  
      * ACC (Accident) - creates it if necessary
 1281  
      * </p>
 1282  
      * 
 1283  
      *
 1284  
      */
 1285  
     public ACC getACC() { 
 1286  0
        return getTyped("ACC", ACC.class);
 1287  
     }
 1288  
 
 1289  
 
 1290  
 
 1291  
 
 1292  
 
 1293  
     /**
 1294  
      * <p>
 1295  
      * Returns
 1296  
      * UB1 (UB82) - creates it if necessary
 1297  
      * </p>
 1298  
      * 
 1299  
      *
 1300  
      */
 1301  
     public UB1 getUB1() { 
 1302  0
        return getTyped("UB1", UB1.class);
 1303  
     }
 1304  
 
 1305  
 
 1306  
 
 1307  
 
 1308  
 
 1309  
     /**
 1310  
      * <p>
 1311  
      * Returns
 1312  
      * UB2 (UB92 Data) - creates it if necessary
 1313  
      * </p>
 1314  
      * 
 1315  
      *
 1316  
      */
 1317  
     public UB2 getUB2() { 
 1318  0
        return getTyped("UB2", UB2.class);
 1319  
     }
 1320  
 
 1321  
 
 1322  
 
 1323  
 
 1324  
 
 1325  
     /**
 1326  
      * <p>
 1327  
      * Returns
 1328  
      * PDA (Patient Death and Autopsy) - creates it if necessary
 1329  
      * </p>
 1330  
      * 
 1331  
      *
 1332  
      */
 1333  
     public PDA getPDA() { 
 1334  0
        return getTyped("PDA", PDA.class);
 1335  
     }
 1336  
 
 1337  
 
 1338  
 
 1339  
 
 1340  
 }
 1341