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.v27.message; 035 036import ca.uhn.hl7v2.model.v27.group.*; 037import ca.uhn.hl7v2.model.v27.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: UAC (User Authentication Credential Segment) <b>optional </b> </li> 052 * <li>4: EVN (Event Type) <b> </b> </li> 053 * <li>5: PID (Patient Identification) <b> </b> </li> 054 * <li>6: PD1 (Patient Additional Demographic) <b>optional </b> </li> 055 * <li>7: ARV (Access Restriction) <b>optional repeating</b> </li> 056 * <li>8: ROL (Role) <b>optional repeating</b> </li> 057 * <li>9: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li> 058 * <li>10: PV1 (Patient Visit) <b> </b> </li> 059 * <li>11: PV2 (Patient Visit - Additional Information) <b>optional </b> </li> 060 * <li>12: ARV (Access Restriction) <b>optional repeating</b> </li> 061 * <li>13: ROL (Role) <b>optional repeating</b> </li> 062 * <li>14: DB1 (Disability) <b>optional repeating</b> </li> 063 * <li>15: AL1 (Patient Allergy Information) <b>optional repeating</b> </li> 064 * <li>16: DG1 (Diagnosis) <b>optional repeating</b> </li> 065 * <li>17: DRG (Diagnosis Related Group) <b>optional </b> </li> 066 * <li>18: ADT_A03_PROCEDURE (a Group object) <b>optional repeating</b> </li> 067 * <li>19: OBX (Observation/Result) <b>optional repeating</b> </li> 068 * <li>20: GT1 (Guarantor) <b>optional repeating</b> </li> 069 * <li>21: ADT_A03_INSURANCE (a Group object) <b>optional repeating</b> </li> 070 * <li>22: ACC (Accident) <b>optional </b> </li> 071 * <li>23: PDA (Patient Death and Autopsy) <b>optional </b> </li> 072 * </ul> 073 */ 074//@SuppressWarnings("unused") 075public class ADT_A03 extends AbstractMessage { 076 077 /** 078 * Creates a new ADT_A03 message with DefaultModelClassFactory. 079 */ 080 public ADT_A03() { 081 this(new DefaultModelClassFactory()); 082 } 083 084 /** 085 * Creates a new ADT_A03 message with custom ModelClassFactory. 086 */ 087 public ADT_A03(ModelClassFactory factory) { 088 super(factory); 089 init(factory); 090 } 091 092 private void init(ModelClassFactory factory) { 093 try { 094 this.add(MSH.class, true, false); 095 this.add(SFT.class, false, true); 096 this.add(UAC.class, false, false); 097 this.add(EVN.class, true, false); 098 this.add(PID.class, true, false); 099 this.add(PD1.class, false, false); 100 this.add(ARV.class, false, true); 101 this.add(ROL.class, false, true); 102 this.add(NK1.class, false, true); 103 this.add(PV1.class, true, false); 104 this.add(PV2.class, false, false); 105 this.add(ARV.class, false, true); 106 this.add(ROL.class, false, true); 107 this.add(DB1.class, false, true); 108 this.add(AL1.class, false, true); 109 this.add(DG1.class, false, true); 110 this.add(DRG.class, false, false); 111 this.add(ADT_A03_PROCEDURE.class, false, true); 112 this.add(OBX.class, false, true); 113 this.add(GT1.class, false, true); 114 this.add(ADT_A03_INSURANCE.class, false, true); 115 this.add(ACC.class, false, false); 116 this.add(PDA.class, false, false); 117 } catch(HL7Exception e) { 118 log.error("Unexpected error creating ADT_A03 - this is probably a bug in the source code generator.", e); 119 } 120 } 121 122 123 /** 124 * Returns "2.7" 125 */ 126 public String getVersion() { 127 return "2.7"; 128 } 129 130 131 132 133 /** 134 * <p> 135 * Returns 136 * MSH (Message Header) - creates it if necessary 137 * </p> 138 * 139 * 140 */ 141 public MSH getMSH() { 142 return getTyped("MSH", MSH.class); 143 } 144 145 146 147 148 149 /** 150 * <p> 151 * Returns 152 * the first repetition of 153 * SFT (Software Segment) - creates it if necessary 154 * </p> 155 * 156 * 157 */ 158 public SFT getSFT() { 159 return getTyped("SFT", SFT.class); 160 } 161 162 163 /** 164 * <p> 165 * Returns a specific repetition of 166 * SFT (Software Segment) - creates it if necessary 167 * </p> 168 * 169 * 170 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 171 * @throws HL7Exception if the repetition requested is more than one 172 * greater than the number of existing repetitions. 173 */ 174 public SFT getSFT(int rep) { 175 return getTyped("SFT", rep, SFT.class); 176 } 177 178 /** 179 * <p> 180 * Returns the number of existing repetitions of SFT 181 * </p> 182 * 183 */ 184 public int getSFTReps() { 185 return getReps("SFT"); 186 } 187 188 /** 189 * <p> 190 * Returns a non-modifiable List containing all current existing repetitions of SFT. 191 * <p> 192 * <p> 193 * Note that unlike {@link #getSFT()}, this method will not create any reps 194 * if none are already present, so an empty list may be returned. 195 * </p> 196 * 197 */ 198 public java.util.List<SFT> getSFTAll() throws HL7Exception { 199 return getAllAsList("SFT", SFT.class); 200 } 201 202 /** 203 * <p> 204 * Inserts a specific repetition of SFT (Software Segment) 205 * </p> 206 * 207 * 208 * @see AbstractGroup#insertRepetition(Structure, int) 209 */ 210 public void insertSFT(SFT structure, int rep) throws HL7Exception { 211 super.insertRepetition( "SFT", structure, rep); 212 } 213 214 215 /** 216 * <p> 217 * Inserts a specific repetition of SFT (Software Segment) 218 * </p> 219 * 220 * 221 * @see AbstractGroup#insertRepetition(Structure, int) 222 */ 223 public SFT insertSFT(int rep) throws HL7Exception { 224 return (SFT)super.insertRepetition("SFT", rep); 225 } 226 227 228 /** 229 * <p> 230 * Removes a specific repetition of SFT (Software Segment) 231 * </p> 232 * 233 * 234 * @see AbstractGroup#removeRepetition(String, int) 235 */ 236 public SFT removeSFT(int rep) throws HL7Exception { 237 return (SFT)super.removeRepetition("SFT", rep); 238 } 239 240 241 242 243 /** 244 * <p> 245 * Returns 246 * UAC (User Authentication Credential Segment) - creates it if necessary 247 * </p> 248 * 249 * 250 */ 251 public UAC getUAC() { 252 return getTyped("UAC", UAC.class); 253 } 254 255 256 257 258 259 /** 260 * <p> 261 * Returns 262 * EVN (Event Type) - creates it if necessary 263 * </p> 264 * 265 * 266 */ 267 public EVN getEVN() { 268 return getTyped("EVN", EVN.class); 269 } 270 271 272 273 274 275 /** 276 * <p> 277 * Returns 278 * PID (Patient Identification) - creates it if necessary 279 * </p> 280 * 281 * 282 */ 283 public PID getPID() { 284 return getTyped("PID", PID.class); 285 } 286 287 288 289 290 291 /** 292 * <p> 293 * Returns 294 * PD1 (Patient Additional Demographic) - creates it if necessary 295 * </p> 296 * 297 * 298 */ 299 public PD1 getPD1() { 300 return getTyped("PD1", PD1.class); 301 } 302 303 304 305 306 307 /** 308 * <p> 309 * Returns 310 * the first repetition of 311 * ARV (Access Restriction) - creates it if necessary 312 * </p> 313 * 314 * 315 */ 316 public ARV getARV() { 317 return getTyped("ARV", ARV.class); 318 } 319 320 321 /** 322 * <p> 323 * Returns a specific repetition of 324 * ARV (Access Restriction) - creates it if necessary 325 * </p> 326 * 327 * 328 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 329 * @throws HL7Exception if the repetition requested is more than one 330 * greater than the number of existing repetitions. 331 */ 332 public ARV getARV(int rep) { 333 return getTyped("ARV", rep, ARV.class); 334 } 335 336 /** 337 * <p> 338 * Returns the number of existing repetitions of ARV 339 * </p> 340 * 341 */ 342 public int getARVReps() { 343 return getReps("ARV"); 344 } 345 346 /** 347 * <p> 348 * Returns a non-modifiable List containing all current existing repetitions of ARV. 349 * <p> 350 * <p> 351 * Note that unlike {@link #getARV()}, this method will not create any reps 352 * if none are already present, so an empty list may be returned. 353 * </p> 354 * 355 */ 356 public java.util.List<ARV> getARVAll() throws HL7Exception { 357 return getAllAsList("ARV", ARV.class); 358 } 359 360 /** 361 * <p> 362 * Inserts a specific repetition of ARV (Access Restriction) 363 * </p> 364 * 365 * 366 * @see AbstractGroup#insertRepetition(Structure, int) 367 */ 368 public void insertARV(ARV structure, int rep) throws HL7Exception { 369 super.insertRepetition( "ARV", structure, rep); 370 } 371 372 373 /** 374 * <p> 375 * Inserts a specific repetition of ARV (Access Restriction) 376 * </p> 377 * 378 * 379 * @see AbstractGroup#insertRepetition(Structure, int) 380 */ 381 public ARV insertARV(int rep) throws HL7Exception { 382 return (ARV)super.insertRepetition("ARV", rep); 383 } 384 385 386 /** 387 * <p> 388 * Removes a specific repetition of ARV (Access Restriction) 389 * </p> 390 * 391 * 392 * @see AbstractGroup#removeRepetition(String, int) 393 */ 394 public ARV removeARV(int rep) throws HL7Exception { 395 return (ARV)super.removeRepetition("ARV", rep); 396 } 397 398 399 400 401 /** 402 * <p> 403 * Returns 404 * the first repetition of 405 * ROL (Role) - creates it if necessary 406 * </p> 407 * 408 * 409 */ 410 public ROL getROL() { 411 return getTyped("ROL", ROL.class); 412 } 413 414 415 /** 416 * <p> 417 * Returns a specific repetition of 418 * ROL (Role) - creates it if necessary 419 * </p> 420 * 421 * 422 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 423 * @throws HL7Exception if the repetition requested is more than one 424 * greater than the number of existing repetitions. 425 */ 426 public ROL getROL(int rep) { 427 return getTyped("ROL", rep, ROL.class); 428 } 429 430 /** 431 * <p> 432 * Returns the number of existing repetitions of ROL 433 * </p> 434 * 435 */ 436 public int getROLReps() { 437 return getReps("ROL"); 438 } 439 440 /** 441 * <p> 442 * Returns a non-modifiable List containing all current existing repetitions of ROL. 443 * <p> 444 * <p> 445 * Note that unlike {@link #getROL()}, this method will not create any reps 446 * if none are already present, so an empty list may be returned. 447 * </p> 448 * 449 */ 450 public java.util.List<ROL> getROLAll() throws HL7Exception { 451 return getAllAsList("ROL", ROL.class); 452 } 453 454 /** 455 * <p> 456 * Inserts a specific repetition of ROL (Role) 457 * </p> 458 * 459 * 460 * @see AbstractGroup#insertRepetition(Structure, int) 461 */ 462 public void insertROL(ROL structure, int rep) throws HL7Exception { 463 super.insertRepetition( "ROL", structure, rep); 464 } 465 466 467 /** 468 * <p> 469 * Inserts a specific repetition of ROL (Role) 470 * </p> 471 * 472 * 473 * @see AbstractGroup#insertRepetition(Structure, int) 474 */ 475 public ROL insertROL(int rep) throws HL7Exception { 476 return (ROL)super.insertRepetition("ROL", rep); 477 } 478 479 480 /** 481 * <p> 482 * Removes a specific repetition of ROL (Role) 483 * </p> 484 * 485 * 486 * @see AbstractGroup#removeRepetition(String, int) 487 */ 488 public ROL removeROL(int rep) throws HL7Exception { 489 return (ROL)super.removeRepetition("ROL", rep); 490 } 491 492 493 494 495 /** 496 * <p> 497 * Returns 498 * the first repetition of 499 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 500 * </p> 501 * 502 * 503 */ 504 public NK1 getNK1() { 505 return getTyped("NK1", NK1.class); 506 } 507 508 509 /** 510 * <p> 511 * Returns a specific repetition of 512 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 513 * </p> 514 * 515 * 516 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 517 * @throws HL7Exception if the repetition requested is more than one 518 * greater than the number of existing repetitions. 519 */ 520 public NK1 getNK1(int rep) { 521 return getTyped("NK1", rep, NK1.class); 522 } 523 524 /** 525 * <p> 526 * Returns the number of existing repetitions of NK1 527 * </p> 528 * 529 */ 530 public int getNK1Reps() { 531 return getReps("NK1"); 532 } 533 534 /** 535 * <p> 536 * Returns a non-modifiable List containing all current existing repetitions of NK1. 537 * <p> 538 * <p> 539 * Note that unlike {@link #getNK1()}, this method will not create any reps 540 * if none are already present, so an empty list may be returned. 541 * </p> 542 * 543 */ 544 public java.util.List<NK1> getNK1All() throws HL7Exception { 545 return getAllAsList("NK1", NK1.class); 546 } 547 548 /** 549 * <p> 550 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 551 * </p> 552 * 553 * 554 * @see AbstractGroup#insertRepetition(Structure, int) 555 */ 556 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 557 super.insertRepetition( "NK1", structure, rep); 558 } 559 560 561 /** 562 * <p> 563 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 564 * </p> 565 * 566 * 567 * @see AbstractGroup#insertRepetition(Structure, int) 568 */ 569 public NK1 insertNK1(int rep) throws HL7Exception { 570 return (NK1)super.insertRepetition("NK1", rep); 571 } 572 573 574 /** 575 * <p> 576 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties) 577 * </p> 578 * 579 * 580 * @see AbstractGroup#removeRepetition(String, int) 581 */ 582 public NK1 removeNK1(int rep) throws HL7Exception { 583 return (NK1)super.removeRepetition("NK1", rep); 584 } 585 586 587 588 589 /** 590 * <p> 591 * Returns 592 * PV1 (Patient Visit) - creates it if necessary 593 * </p> 594 * 595 * 596 */ 597 public PV1 getPV1() { 598 return getTyped("PV1", PV1.class); 599 } 600 601 602 603 604 605 /** 606 * <p> 607 * Returns 608 * PV2 (Patient Visit - Additional Information) - creates it if necessary 609 * </p> 610 * 611 * 612 */ 613 public PV2 getPV2() { 614 return getTyped("PV2", PV2.class); 615 } 616 617 618 619 620 621 /** 622 * <p> 623 * Returns 624 * the first repetition of 625 * ARV2 (Access Restriction) - creates it if necessary 626 * </p> 627 * 628 * 629 */ 630 public ARV getARV2() { 631 return getTyped("ARV2", ARV.class); 632 } 633 634 635 /** 636 * <p> 637 * Returns a specific repetition of 638 * ARV2 (Access Restriction) - creates it if necessary 639 * </p> 640 * 641 * 642 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 643 * @throws HL7Exception if the repetition requested is more than one 644 * greater than the number of existing repetitions. 645 */ 646 public ARV getARV2(int rep) { 647 return getTyped("ARV2", rep, ARV.class); 648 } 649 650 /** 651 * <p> 652 * Returns the number of existing repetitions of ARV2 653 * </p> 654 * 655 */ 656 public int getARV2Reps() { 657 return getReps("ARV2"); 658 } 659 660 /** 661 * <p> 662 * Returns a non-modifiable List containing all current existing repetitions of ARV2. 663 * <p> 664 * <p> 665 * Note that unlike {@link #getARV2()}, this method will not create any reps 666 * if none are already present, so an empty list may be returned. 667 * </p> 668 * 669 */ 670 public java.util.List<ARV> getARV2All() throws HL7Exception { 671 return getAllAsList("ARV2", ARV.class); 672 } 673 674 /** 675 * <p> 676 * Inserts a specific repetition of ARV2 (Access Restriction) 677 * </p> 678 * 679 * 680 * @see AbstractGroup#insertRepetition(Structure, int) 681 */ 682 public void insertARV2(ARV structure, int rep) throws HL7Exception { 683 super.insertRepetition( "ARV2", structure, rep); 684 } 685 686 687 /** 688 * <p> 689 * Inserts a specific repetition of ARV2 (Access Restriction) 690 * </p> 691 * 692 * 693 * @see AbstractGroup#insertRepetition(Structure, int) 694 */ 695 public ARV insertARV2(int rep) throws HL7Exception { 696 return (ARV)super.insertRepetition("ARV2", rep); 697 } 698 699 700 /** 701 * <p> 702 * Removes a specific repetition of ARV2 (Access Restriction) 703 * </p> 704 * 705 * 706 * @see AbstractGroup#removeRepetition(String, int) 707 */ 708 public ARV removeARV2(int rep) throws HL7Exception { 709 return (ARV)super.removeRepetition("ARV2", rep); 710 } 711 712 713 714 715 /** 716 * <p> 717 * Returns 718 * the first repetition of 719 * ROL2 (Role) - creates it if necessary 720 * </p> 721 * 722 * 723 */ 724 public ROL getROL2() { 725 return getTyped("ROL2", ROL.class); 726 } 727 728 729 /** 730 * <p> 731 * Returns a specific repetition of 732 * ROL2 (Role) - creates it if necessary 733 * </p> 734 * 735 * 736 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 737 * @throws HL7Exception if the repetition requested is more than one 738 * greater than the number of existing repetitions. 739 */ 740 public ROL getROL2(int rep) { 741 return getTyped("ROL2", rep, ROL.class); 742 } 743 744 /** 745 * <p> 746 * Returns the number of existing repetitions of ROL2 747 * </p> 748 * 749 */ 750 public int getROL2Reps() { 751 return getReps("ROL2"); 752 } 753 754 /** 755 * <p> 756 * Returns a non-modifiable List containing all current existing repetitions of ROL2. 757 * <p> 758 * <p> 759 * Note that unlike {@link #getROL2()}, this method will not create any reps 760 * if none are already present, so an empty list may be returned. 761 * </p> 762 * 763 */ 764 public java.util.List<ROL> getROL2All() throws HL7Exception { 765 return getAllAsList("ROL2", ROL.class); 766 } 767 768 /** 769 * <p> 770 * Inserts a specific repetition of ROL2 (Role) 771 * </p> 772 * 773 * 774 * @see AbstractGroup#insertRepetition(Structure, int) 775 */ 776 public void insertROL2(ROL structure, int rep) throws HL7Exception { 777 super.insertRepetition( "ROL2", structure, rep); 778 } 779 780 781 /** 782 * <p> 783 * Inserts a specific repetition of ROL2 (Role) 784 * </p> 785 * 786 * 787 * @see AbstractGroup#insertRepetition(Structure, int) 788 */ 789 public ROL insertROL2(int rep) throws HL7Exception { 790 return (ROL)super.insertRepetition("ROL2", rep); 791 } 792 793 794 /** 795 * <p> 796 * Removes a specific repetition of ROL2 (Role) 797 * </p> 798 * 799 * 800 * @see AbstractGroup#removeRepetition(String, int) 801 */ 802 public ROL removeROL2(int rep) throws HL7Exception { 803 return (ROL)super.removeRepetition("ROL2", rep); 804 } 805 806 807 808 809 /** 810 * <p> 811 * Returns 812 * the first repetition of 813 * DB1 (Disability) - creates it if necessary 814 * </p> 815 * 816 * 817 */ 818 public DB1 getDB1() { 819 return getTyped("DB1", DB1.class); 820 } 821 822 823 /** 824 * <p> 825 * Returns a specific repetition of 826 * DB1 (Disability) - creates it if necessary 827 * </p> 828 * 829 * 830 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 831 * @throws HL7Exception if the repetition requested is more than one 832 * greater than the number of existing repetitions. 833 */ 834 public DB1 getDB1(int rep) { 835 return getTyped("DB1", rep, DB1.class); 836 } 837 838 /** 839 * <p> 840 * Returns the number of existing repetitions of DB1 841 * </p> 842 * 843 */ 844 public int getDB1Reps() { 845 return getReps("DB1"); 846 } 847 848 /** 849 * <p> 850 * Returns a non-modifiable List containing all current existing repetitions of DB1. 851 * <p> 852 * <p> 853 * Note that unlike {@link #getDB1()}, this method will not create any reps 854 * if none are already present, so an empty list may be returned. 855 * </p> 856 * 857 */ 858 public java.util.List<DB1> getDB1All() throws HL7Exception { 859 return getAllAsList("DB1", DB1.class); 860 } 861 862 /** 863 * <p> 864 * Inserts a specific repetition of DB1 (Disability) 865 * </p> 866 * 867 * 868 * @see AbstractGroup#insertRepetition(Structure, int) 869 */ 870 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 871 super.insertRepetition( "DB1", structure, rep); 872 } 873 874 875 /** 876 * <p> 877 * Inserts a specific repetition of DB1 (Disability) 878 * </p> 879 * 880 * 881 * @see AbstractGroup#insertRepetition(Structure, int) 882 */ 883 public DB1 insertDB1(int rep) throws HL7Exception { 884 return (DB1)super.insertRepetition("DB1", rep); 885 } 886 887 888 /** 889 * <p> 890 * Removes a specific repetition of DB1 (Disability) 891 * </p> 892 * 893 * 894 * @see AbstractGroup#removeRepetition(String, int) 895 */ 896 public DB1 removeDB1(int rep) throws HL7Exception { 897 return (DB1)super.removeRepetition("DB1", rep); 898 } 899 900 901 902 903 /** 904 * <p> 905 * Returns 906 * the first repetition of 907 * AL1 (Patient Allergy Information) - creates it if necessary 908 * </p> 909 * 910 * 911 */ 912 public AL1 getAL1() { 913 return getTyped("AL1", AL1.class); 914 } 915 916 917 /** 918 * <p> 919 * Returns a specific repetition of 920 * AL1 (Patient Allergy Information) - creates it if necessary 921 * </p> 922 * 923 * 924 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 925 * @throws HL7Exception if the repetition requested is more than one 926 * greater than the number of existing repetitions. 927 */ 928 public AL1 getAL1(int rep) { 929 return getTyped("AL1", rep, AL1.class); 930 } 931 932 /** 933 * <p> 934 * Returns the number of existing repetitions of AL1 935 * </p> 936 * 937 */ 938 public int getAL1Reps() { 939 return getReps("AL1"); 940 } 941 942 /** 943 * <p> 944 * Returns a non-modifiable List containing all current existing repetitions of AL1. 945 * <p> 946 * <p> 947 * Note that unlike {@link #getAL1()}, this method will not create any reps 948 * if none are already present, so an empty list may be returned. 949 * </p> 950 * 951 */ 952 public java.util.List<AL1> getAL1All() throws HL7Exception { 953 return getAllAsList("AL1", AL1.class); 954 } 955 956 /** 957 * <p> 958 * Inserts a specific repetition of AL1 (Patient Allergy Information) 959 * </p> 960 * 961 * 962 * @see AbstractGroup#insertRepetition(Structure, int) 963 */ 964 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 965 super.insertRepetition( "AL1", structure, rep); 966 } 967 968 969 /** 970 * <p> 971 * Inserts a specific repetition of AL1 (Patient Allergy Information) 972 * </p> 973 * 974 * 975 * @see AbstractGroup#insertRepetition(Structure, int) 976 */ 977 public AL1 insertAL1(int rep) throws HL7Exception { 978 return (AL1)super.insertRepetition("AL1", rep); 979 } 980 981 982 /** 983 * <p> 984 * Removes a specific repetition of AL1 (Patient Allergy Information) 985 * </p> 986 * 987 * 988 * @see AbstractGroup#removeRepetition(String, int) 989 */ 990 public AL1 removeAL1(int rep) throws HL7Exception { 991 return (AL1)super.removeRepetition("AL1", rep); 992 } 993 994 995 996 997 /** 998 * <p> 999 * Returns 1000 * the first repetition of 1001 * DG1 (Diagnosis) - creates it if necessary 1002 * </p> 1003 * 1004 * 1005 */ 1006 public DG1 getDG1() { 1007 return getTyped("DG1", DG1.class); 1008 } 1009 1010 1011 /** 1012 * <p> 1013 * Returns a specific repetition of 1014 * DG1 (Diagnosis) - creates it if necessary 1015 * </p> 1016 * 1017 * 1018 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1019 * @throws HL7Exception if the repetition requested is more than one 1020 * greater than the number of existing repetitions. 1021 */ 1022 public DG1 getDG1(int rep) { 1023 return getTyped("DG1", rep, DG1.class); 1024 } 1025 1026 /** 1027 * <p> 1028 * Returns the number of existing repetitions of DG1 1029 * </p> 1030 * 1031 */ 1032 public int getDG1Reps() { 1033 return getReps("DG1"); 1034 } 1035 1036 /** 1037 * <p> 1038 * Returns a non-modifiable List containing all current existing repetitions of DG1. 1039 * <p> 1040 * <p> 1041 * Note that unlike {@link #getDG1()}, this method will not create any reps 1042 * if none are already present, so an empty list may be returned. 1043 * </p> 1044 * 1045 */ 1046 public java.util.List<DG1> getDG1All() throws HL7Exception { 1047 return getAllAsList("DG1", DG1.class); 1048 } 1049 1050 /** 1051 * <p> 1052 * Inserts a specific repetition of DG1 (Diagnosis) 1053 * </p> 1054 * 1055 * 1056 * @see AbstractGroup#insertRepetition(Structure, int) 1057 */ 1058 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 1059 super.insertRepetition( "DG1", structure, rep); 1060 } 1061 1062 1063 /** 1064 * <p> 1065 * Inserts a specific repetition of DG1 (Diagnosis) 1066 * </p> 1067 * 1068 * 1069 * @see AbstractGroup#insertRepetition(Structure, int) 1070 */ 1071 public DG1 insertDG1(int rep) throws HL7Exception { 1072 return (DG1)super.insertRepetition("DG1", rep); 1073 } 1074 1075 1076 /** 1077 * <p> 1078 * Removes a specific repetition of DG1 (Diagnosis) 1079 * </p> 1080 * 1081 * 1082 * @see AbstractGroup#removeRepetition(String, int) 1083 */ 1084 public DG1 removeDG1(int rep) throws HL7Exception { 1085 return (DG1)super.removeRepetition("DG1", rep); 1086 } 1087 1088 1089 1090 1091 /** 1092 * <p> 1093 * Returns 1094 * DRG (Diagnosis Related Group) - creates it if necessary 1095 * </p> 1096 * 1097 * 1098 */ 1099 public DRG getDRG() { 1100 return getTyped("DRG", DRG.class); 1101 } 1102 1103 1104 1105 1106 1107 /** 1108 * <p> 1109 * Returns 1110 * the first repetition of 1111 * PROCEDURE (a Group object) - creates it if necessary 1112 * </p> 1113 * 1114 * 1115 */ 1116 public ADT_A03_PROCEDURE getPROCEDURE() { 1117 return getTyped("PROCEDURE", ADT_A03_PROCEDURE.class); 1118 } 1119 1120 1121 /** 1122 * <p> 1123 * Returns a specific repetition of 1124 * PROCEDURE (a Group object) - creates it if necessary 1125 * </p> 1126 * 1127 * 1128 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1129 * @throws HL7Exception if the repetition requested is more than one 1130 * greater than the number of existing repetitions. 1131 */ 1132 public ADT_A03_PROCEDURE getPROCEDURE(int rep) { 1133 return getTyped("PROCEDURE", rep, ADT_A03_PROCEDURE.class); 1134 } 1135 1136 /** 1137 * <p> 1138 * Returns the number of existing repetitions of PROCEDURE 1139 * </p> 1140 * 1141 */ 1142 public int getPROCEDUREReps() { 1143 return getReps("PROCEDURE"); 1144 } 1145 1146 /** 1147 * <p> 1148 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 1149 * <p> 1150 * <p> 1151 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 1152 * if none are already present, so an empty list may be returned. 1153 * </p> 1154 * 1155 */ 1156 public java.util.List<ADT_A03_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 1157 return getAllAsList("PROCEDURE", ADT_A03_PROCEDURE.class); 1158 } 1159 1160 /** 1161 * <p> 1162 * Inserts a specific repetition of PROCEDURE (a Group object) 1163 * </p> 1164 * 1165 * 1166 * @see AbstractGroup#insertRepetition(Structure, int) 1167 */ 1168 public void insertPROCEDURE(ADT_A03_PROCEDURE structure, int rep) throws HL7Exception { 1169 super.insertRepetition( "PROCEDURE", structure, rep); 1170 } 1171 1172 1173 /** 1174 * <p> 1175 * Inserts a specific repetition of PROCEDURE (a Group object) 1176 * </p> 1177 * 1178 * 1179 * @see AbstractGroup#insertRepetition(Structure, int) 1180 */ 1181 public ADT_A03_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 1182 return (ADT_A03_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 1183 } 1184 1185 1186 /** 1187 * <p> 1188 * Removes a specific repetition of PROCEDURE (a Group object) 1189 * </p> 1190 * 1191 * 1192 * @see AbstractGroup#removeRepetition(String, int) 1193 */ 1194 public ADT_A03_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 1195 return (ADT_A03_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 1196 } 1197 1198 1199 1200 1201 /** 1202 * <p> 1203 * Returns 1204 * the first repetition of 1205 * OBX (Observation/Result) - creates it if necessary 1206 * </p> 1207 * 1208 * 1209 */ 1210 public OBX getOBX() { 1211 return getTyped("OBX", OBX.class); 1212 } 1213 1214 1215 /** 1216 * <p> 1217 * Returns a specific repetition of 1218 * OBX (Observation/Result) - creates it if necessary 1219 * </p> 1220 * 1221 * 1222 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1223 * @throws HL7Exception if the repetition requested is more than one 1224 * greater than the number of existing repetitions. 1225 */ 1226 public OBX getOBX(int rep) { 1227 return getTyped("OBX", rep, OBX.class); 1228 } 1229 1230 /** 1231 * <p> 1232 * Returns the number of existing repetitions of OBX 1233 * </p> 1234 * 1235 */ 1236 public int getOBXReps() { 1237 return getReps("OBX"); 1238 } 1239 1240 /** 1241 * <p> 1242 * Returns a non-modifiable List containing all current existing repetitions of OBX. 1243 * <p> 1244 * <p> 1245 * Note that unlike {@link #getOBX()}, this method will not create any reps 1246 * if none are already present, so an empty list may be returned. 1247 * </p> 1248 * 1249 */ 1250 public java.util.List<OBX> getOBXAll() throws HL7Exception { 1251 return getAllAsList("OBX", OBX.class); 1252 } 1253 1254 /** 1255 * <p> 1256 * Inserts a specific repetition of OBX (Observation/Result) 1257 * </p> 1258 * 1259 * 1260 * @see AbstractGroup#insertRepetition(Structure, int) 1261 */ 1262 public void insertOBX(OBX structure, int rep) throws HL7Exception { 1263 super.insertRepetition( "OBX", structure, rep); 1264 } 1265 1266 1267 /** 1268 * <p> 1269 * Inserts a specific repetition of OBX (Observation/Result) 1270 * </p> 1271 * 1272 * 1273 * @see AbstractGroup#insertRepetition(Structure, int) 1274 */ 1275 public OBX insertOBX(int rep) throws HL7Exception { 1276 return (OBX)super.insertRepetition("OBX", rep); 1277 } 1278 1279 1280 /** 1281 * <p> 1282 * Removes a specific repetition of OBX (Observation/Result) 1283 * </p> 1284 * 1285 * 1286 * @see AbstractGroup#removeRepetition(String, int) 1287 */ 1288 public OBX removeOBX(int rep) throws HL7Exception { 1289 return (OBX)super.removeRepetition("OBX", rep); 1290 } 1291 1292 1293 1294 1295 /** 1296 * <p> 1297 * Returns 1298 * the first repetition of 1299 * GT1 (Guarantor) - creates it if necessary 1300 * </p> 1301 * 1302 * 1303 */ 1304 public GT1 getGT1() { 1305 return getTyped("GT1", GT1.class); 1306 } 1307 1308 1309 /** 1310 * <p> 1311 * Returns a specific repetition of 1312 * GT1 (Guarantor) - creates it if necessary 1313 * </p> 1314 * 1315 * 1316 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1317 * @throws HL7Exception if the repetition requested is more than one 1318 * greater than the number of existing repetitions. 1319 */ 1320 public GT1 getGT1(int rep) { 1321 return getTyped("GT1", rep, GT1.class); 1322 } 1323 1324 /** 1325 * <p> 1326 * Returns the number of existing repetitions of GT1 1327 * </p> 1328 * 1329 */ 1330 public int getGT1Reps() { 1331 return getReps("GT1"); 1332 } 1333 1334 /** 1335 * <p> 1336 * Returns a non-modifiable List containing all current existing repetitions of GT1. 1337 * <p> 1338 * <p> 1339 * Note that unlike {@link #getGT1()}, this method will not create any reps 1340 * if none are already present, so an empty list may be returned. 1341 * </p> 1342 * 1343 */ 1344 public java.util.List<GT1> getGT1All() throws HL7Exception { 1345 return getAllAsList("GT1", GT1.class); 1346 } 1347 1348 /** 1349 * <p> 1350 * Inserts a specific repetition of GT1 (Guarantor) 1351 * </p> 1352 * 1353 * 1354 * @see AbstractGroup#insertRepetition(Structure, int) 1355 */ 1356 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 1357 super.insertRepetition( "GT1", structure, rep); 1358 } 1359 1360 1361 /** 1362 * <p> 1363 * Inserts a specific repetition of GT1 (Guarantor) 1364 * </p> 1365 * 1366 * 1367 * @see AbstractGroup#insertRepetition(Structure, int) 1368 */ 1369 public GT1 insertGT1(int rep) throws HL7Exception { 1370 return (GT1)super.insertRepetition("GT1", rep); 1371 } 1372 1373 1374 /** 1375 * <p> 1376 * Removes a specific repetition of GT1 (Guarantor) 1377 * </p> 1378 * 1379 * 1380 * @see AbstractGroup#removeRepetition(String, int) 1381 */ 1382 public GT1 removeGT1(int rep) throws HL7Exception { 1383 return (GT1)super.removeRepetition("GT1", rep); 1384 } 1385 1386 1387 1388 1389 /** 1390 * <p> 1391 * Returns 1392 * the first repetition of 1393 * INSURANCE (a Group object) - creates it if necessary 1394 * </p> 1395 * 1396 * 1397 */ 1398 public ADT_A03_INSURANCE getINSURANCE() { 1399 return getTyped("INSURANCE", ADT_A03_INSURANCE.class); 1400 } 1401 1402 1403 /** 1404 * <p> 1405 * Returns a specific repetition of 1406 * INSURANCE (a Group object) - creates it if necessary 1407 * </p> 1408 * 1409 * 1410 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1411 * @throws HL7Exception if the repetition requested is more than one 1412 * greater than the number of existing repetitions. 1413 */ 1414 public ADT_A03_INSURANCE getINSURANCE(int rep) { 1415 return getTyped("INSURANCE", rep, ADT_A03_INSURANCE.class); 1416 } 1417 1418 /** 1419 * <p> 1420 * Returns the number of existing repetitions of INSURANCE 1421 * </p> 1422 * 1423 */ 1424 public int getINSURANCEReps() { 1425 return getReps("INSURANCE"); 1426 } 1427 1428 /** 1429 * <p> 1430 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 1431 * <p> 1432 * <p> 1433 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 1434 * if none are already present, so an empty list may be returned. 1435 * </p> 1436 * 1437 */ 1438 public java.util.List<ADT_A03_INSURANCE> getINSURANCEAll() throws HL7Exception { 1439 return getAllAsList("INSURANCE", ADT_A03_INSURANCE.class); 1440 } 1441 1442 /** 1443 * <p> 1444 * Inserts a specific repetition of INSURANCE (a Group object) 1445 * </p> 1446 * 1447 * 1448 * @see AbstractGroup#insertRepetition(Structure, int) 1449 */ 1450 public void insertINSURANCE(ADT_A03_INSURANCE structure, int rep) throws HL7Exception { 1451 super.insertRepetition( "INSURANCE", structure, rep); 1452 } 1453 1454 1455 /** 1456 * <p> 1457 * Inserts a specific repetition of INSURANCE (a Group object) 1458 * </p> 1459 * 1460 * 1461 * @see AbstractGroup#insertRepetition(Structure, int) 1462 */ 1463 public ADT_A03_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 1464 return (ADT_A03_INSURANCE)super.insertRepetition("INSURANCE", rep); 1465 } 1466 1467 1468 /** 1469 * <p> 1470 * Removes a specific repetition of INSURANCE (a Group object) 1471 * </p> 1472 * 1473 * 1474 * @see AbstractGroup#removeRepetition(String, int) 1475 */ 1476 public ADT_A03_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 1477 return (ADT_A03_INSURANCE)super.removeRepetition("INSURANCE", rep); 1478 } 1479 1480 1481 1482 1483 /** 1484 * <p> 1485 * Returns 1486 * ACC (Accident) - creates it if necessary 1487 * </p> 1488 * 1489 * 1490 */ 1491 public ACC getACC() { 1492 return getTyped("ACC", ACC.class); 1493 } 1494 1495 1496 1497 1498 1499 /** 1500 * <p> 1501 * Returns 1502 * PDA (Patient Death and Autopsy) - creates it if necessary 1503 * </p> 1504 * 1505 * 1506 */ 1507 public PDA getPDA() { 1508 return getTyped("PDA", PDA.class); 1509 } 1510 1511 1512 1513 1514} 1515