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