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