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.v26.message; 35 36 import ca.uhn.hl7v2.model.v26.group.*; 37 import ca.uhn.hl7v2.model.v26.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_A06 message structure (see chapter 3.3.6). 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: MRG (Merge Patient Information) <b>optional </b> </li> 58 * <li>10: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li> 59 * <li>11: PV1 (Patient Visit) <b> </b> </li> 60 * <li>12: PV2 (Patient Visit - Additional Information) <b>optional </b> </li> 61 * <li>13: ARV (Access Restriction) <b>optional repeating</b> </li> 62 * <li>14: ROL (Role) <b>optional repeating</b> </li> 63 * <li>15: DB1 (Disability) <b>optional repeating</b> </li> 64 * <li>16: OBX (Observation/Result) <b>optional repeating</b> </li> 65 * <li>17: AL1 (Patient Allergy Information) <b>optional repeating</b> </li> 66 * <li>18: DG1 (Diagnosis) <b>optional repeating</b> </li> 67 * <li>19: DRG (Diagnosis Related Group) <b>optional </b> </li> 68 * <li>20: ADT_A06_PROCEDURE (a Group object) <b>optional repeating</b> </li> 69 * <li>21: GT1 (Guarantor) <b>optional repeating</b> </li> 70 * <li>22: ADT_A06_INSURANCE (a Group object) <b>optional repeating</b> </li> 71 * <li>23: ACC (Accident) <b>optional </b> </li> 72 * <li>24: UB1 (UB82) <b>optional </b> </li> 73 * <li>25: UB2 (UB92 Data) <b>optional </b> </li> 74 * </ul> 75 */ 76 //@SuppressWarnings("unused") 77 public class ADT_A06 extends AbstractMessage { 78 79 /** 80 * Creates a new ADT_A06 message with DefaultModelClassFactory. 81 */ 82 public ADT_A06() { 83 this(new DefaultModelClassFactory()); 84 } 85 86 /** 87 * Creates a new ADT_A06 message with custom ModelClassFactory. 88 */ 89 public ADT_A06(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(MRG.class, false, false); 105 this.add(NK1.class, false, true); 106 this.add(PV1.class, true, false); 107 this.add(PV2.class, false, false); 108 this.add(ARV.class, false, true); 109 this.add(ROL.class, false, true); 110 this.add(DB1.class, false, true); 111 this.add(OBX.class, false, true); 112 this.add(AL1.class, false, true); 113 this.add(DG1.class, false, true); 114 this.add(DRG.class, false, false); 115 this.add(ADT_A06_PROCEDURE.class, false, true); 116 this.add(GT1.class, false, true); 117 this.add(ADT_A06_INSURANCE.class, false, true); 118 this.add(ACC.class, false, false); 119 this.add(UB1.class, false, false); 120 this.add(UB2.class, false, false); 121 } catch(HL7Exception e) { 122 log.error("Unexpected error creating ADT_A06 - this is probably a bug in the source code generator.", e); 123 } 124 } 125 126 127 /** 128 * Returns "2.6" 129 */ 130 public String getVersion() { 131 return "2.6"; 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 * MRG (Merge Patient Information) - creates it if necessary 503 * </p> 504 * 505 * 506 */ 507 public MRG getMRG() { 508 return getTyped("MRG", MRG.class); 509 } 510 511 512 513 514 515 /** 516 * <p> 517 * Returns 518 * the first repetition of 519 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 520 * </p> 521 * 522 * 523 */ 524 public NK1 getNK1() { 525 return getTyped("NK1", NK1.class); 526 } 527 528 529 /** 530 * <p> 531 * Returns a specific repetition of 532 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 533 * </p> 534 * 535 * 536 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 537 * @throws HL7Exception if the repetition requested is more than one 538 * greater than the number of existing repetitions. 539 */ 540 public NK1 getNK1(int rep) { 541 return getTyped("NK1", rep, NK1.class); 542 } 543 544 /** 545 * <p> 546 * Returns the number of existing repetitions of NK1 547 * </p> 548 * 549 */ 550 public int getNK1Reps() { 551 return getReps("NK1"); 552 } 553 554 /** 555 * <p> 556 * Returns a non-modifiable List containing all current existing repetitions of NK1. 557 * <p> 558 * <p> 559 * Note that unlike {@link #getNK1()}, this method will not create any reps 560 * if none are already present, so an empty list may be returned. 561 * </p> 562 * 563 */ 564 public java.util.List<NK1> getNK1All() throws HL7Exception { 565 return getAllAsList("NK1", NK1.class); 566 } 567 568 /** 569 * <p> 570 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 571 * </p> 572 * 573 * 574 * @see AbstractGroup#insertRepetition(Structure, int) 575 */ 576 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 577 super.insertRepetition( "NK1", structure, rep); 578 } 579 580 581 /** 582 * <p> 583 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 584 * </p> 585 * 586 * 587 * @see AbstractGroup#insertRepetition(Structure, int) 588 */ 589 public NK1 insertNK1(int rep) throws HL7Exception { 590 return (NK1)super.insertRepetition("NK1", rep); 591 } 592 593 594 /** 595 * <p> 596 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties) 597 * </p> 598 * 599 * 600 * @see AbstractGroup#removeRepetition(String, int) 601 */ 602 public NK1 removeNK1(int rep) throws HL7Exception { 603 return (NK1)super.removeRepetition("NK1", rep); 604 } 605 606 607 608 609 /** 610 * <p> 611 * Returns 612 * PV1 (Patient Visit) - creates it if necessary 613 * </p> 614 * 615 * 616 */ 617 public PV1 getPV1() { 618 return getTyped("PV1", PV1.class); 619 } 620 621 622 623 624 625 /** 626 * <p> 627 * Returns 628 * PV2 (Patient Visit - Additional Information) - creates it if necessary 629 * </p> 630 * 631 * 632 */ 633 public PV2 getPV2() { 634 return getTyped("PV2", PV2.class); 635 } 636 637 638 639 640 641 /** 642 * <p> 643 * Returns 644 * the first repetition of 645 * ARV2 (Access Restriction) - creates it if necessary 646 * </p> 647 * 648 * 649 */ 650 public ARV getARV2() { 651 return getTyped("ARV2", ARV.class); 652 } 653 654 655 /** 656 * <p> 657 * Returns a specific repetition of 658 * ARV2 (Access Restriction) - creates it if necessary 659 * </p> 660 * 661 * 662 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 663 * @throws HL7Exception if the repetition requested is more than one 664 * greater than the number of existing repetitions. 665 */ 666 public ARV getARV2(int rep) { 667 return getTyped("ARV2", rep, ARV.class); 668 } 669 670 /** 671 * <p> 672 * Returns the number of existing repetitions of ARV2 673 * </p> 674 * 675 */ 676 public int getARV2Reps() { 677 return getReps("ARV2"); 678 } 679 680 /** 681 * <p> 682 * Returns a non-modifiable List containing all current existing repetitions of ARV2. 683 * <p> 684 * <p> 685 * Note that unlike {@link #getARV2()}, this method will not create any reps 686 * if none are already present, so an empty list may be returned. 687 * </p> 688 * 689 */ 690 public java.util.List<ARV> getARV2All() throws HL7Exception { 691 return getAllAsList("ARV2", ARV.class); 692 } 693 694 /** 695 * <p> 696 * Inserts a specific repetition of ARV2 (Access Restriction) 697 * </p> 698 * 699 * 700 * @see AbstractGroup#insertRepetition(Structure, int) 701 */ 702 public void insertARV2(ARV structure, int rep) throws HL7Exception { 703 super.insertRepetition( "ARV2", structure, rep); 704 } 705 706 707 /** 708 * <p> 709 * Inserts a specific repetition of ARV2 (Access Restriction) 710 * </p> 711 * 712 * 713 * @see AbstractGroup#insertRepetition(Structure, int) 714 */ 715 public ARV insertARV2(int rep) throws HL7Exception { 716 return (ARV)super.insertRepetition("ARV2", rep); 717 } 718 719 720 /** 721 * <p> 722 * Removes a specific repetition of ARV2 (Access Restriction) 723 * </p> 724 * 725 * 726 * @see AbstractGroup#removeRepetition(String, int) 727 */ 728 public ARV removeARV2(int rep) throws HL7Exception { 729 return (ARV)super.removeRepetition("ARV2", rep); 730 } 731 732 733 734 735 /** 736 * <p> 737 * Returns 738 * the first repetition of 739 * ROL2 (Role) - creates it if necessary 740 * </p> 741 * 742 * 743 */ 744 public ROL getROL2() { 745 return getTyped("ROL2", ROL.class); 746 } 747 748 749 /** 750 * <p> 751 * Returns a specific repetition of 752 * ROL2 (Role) - creates it if necessary 753 * </p> 754 * 755 * 756 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 757 * @throws HL7Exception if the repetition requested is more than one 758 * greater than the number of existing repetitions. 759 */ 760 public ROL getROL2(int rep) { 761 return getTyped("ROL2", rep, ROL.class); 762 } 763 764 /** 765 * <p> 766 * Returns the number of existing repetitions of ROL2 767 * </p> 768 * 769 */ 770 public int getROL2Reps() { 771 return getReps("ROL2"); 772 } 773 774 /** 775 * <p> 776 * Returns a non-modifiable List containing all current existing repetitions of ROL2. 777 * <p> 778 * <p> 779 * Note that unlike {@link #getROL2()}, this method will not create any reps 780 * if none are already present, so an empty list may be returned. 781 * </p> 782 * 783 */ 784 public java.util.List<ROL> getROL2All() throws HL7Exception { 785 return getAllAsList("ROL2", ROL.class); 786 } 787 788 /** 789 * <p> 790 * Inserts a specific repetition of ROL2 (Role) 791 * </p> 792 * 793 * 794 * @see AbstractGroup#insertRepetition(Structure, int) 795 */ 796 public void insertROL2(ROL structure, int rep) throws HL7Exception { 797 super.insertRepetition( "ROL2", structure, rep); 798 } 799 800 801 /** 802 * <p> 803 * Inserts a specific repetition of ROL2 (Role) 804 * </p> 805 * 806 * 807 * @see AbstractGroup#insertRepetition(Structure, int) 808 */ 809 public ROL insertROL2(int rep) throws HL7Exception { 810 return (ROL)super.insertRepetition("ROL2", rep); 811 } 812 813 814 /** 815 * <p> 816 * Removes a specific repetition of ROL2 (Role) 817 * </p> 818 * 819 * 820 * @see AbstractGroup#removeRepetition(String, int) 821 */ 822 public ROL removeROL2(int rep) throws HL7Exception { 823 return (ROL)super.removeRepetition("ROL2", rep); 824 } 825 826 827 828 829 /** 830 * <p> 831 * Returns 832 * the first repetition of 833 * DB1 (Disability) - creates it if necessary 834 * </p> 835 * 836 * 837 */ 838 public DB1 getDB1() { 839 return getTyped("DB1", DB1.class); 840 } 841 842 843 /** 844 * <p> 845 * Returns a specific repetition of 846 * DB1 (Disability) - creates it if necessary 847 * </p> 848 * 849 * 850 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 851 * @throws HL7Exception if the repetition requested is more than one 852 * greater than the number of existing repetitions. 853 */ 854 public DB1 getDB1(int rep) { 855 return getTyped("DB1", rep, DB1.class); 856 } 857 858 /** 859 * <p> 860 * Returns the number of existing repetitions of DB1 861 * </p> 862 * 863 */ 864 public int getDB1Reps() { 865 return getReps("DB1"); 866 } 867 868 /** 869 * <p> 870 * Returns a non-modifiable List containing all current existing repetitions of DB1. 871 * <p> 872 * <p> 873 * Note that unlike {@link #getDB1()}, this method will not create any reps 874 * if none are already present, so an empty list may be returned. 875 * </p> 876 * 877 */ 878 public java.util.List<DB1> getDB1All() throws HL7Exception { 879 return getAllAsList("DB1", DB1.class); 880 } 881 882 /** 883 * <p> 884 * Inserts a specific repetition of DB1 (Disability) 885 * </p> 886 * 887 * 888 * @see AbstractGroup#insertRepetition(Structure, int) 889 */ 890 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 891 super.insertRepetition( "DB1", structure, rep); 892 } 893 894 895 /** 896 * <p> 897 * Inserts a specific repetition of DB1 (Disability) 898 * </p> 899 * 900 * 901 * @see AbstractGroup#insertRepetition(Structure, int) 902 */ 903 public DB1 insertDB1(int rep) throws HL7Exception { 904 return (DB1)super.insertRepetition("DB1", rep); 905 } 906 907 908 /** 909 * <p> 910 * Removes a specific repetition of DB1 (Disability) 911 * </p> 912 * 913 * 914 * @see AbstractGroup#removeRepetition(String, int) 915 */ 916 public DB1 removeDB1(int rep) throws HL7Exception { 917 return (DB1)super.removeRepetition("DB1", rep); 918 } 919 920 921 922 923 /** 924 * <p> 925 * Returns 926 * the first repetition of 927 * OBX (Observation/Result) - creates it if necessary 928 * </p> 929 * 930 * 931 */ 932 public OBX getOBX() { 933 return getTyped("OBX", OBX.class); 934 } 935 936 937 /** 938 * <p> 939 * Returns a specific repetition of 940 * OBX (Observation/Result) - creates it if necessary 941 * </p> 942 * 943 * 944 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 945 * @throws HL7Exception if the repetition requested is more than one 946 * greater than the number of existing repetitions. 947 */ 948 public OBX getOBX(int rep) { 949 return getTyped("OBX", rep, OBX.class); 950 } 951 952 /** 953 * <p> 954 * Returns the number of existing repetitions of OBX 955 * </p> 956 * 957 */ 958 public int getOBXReps() { 959 return getReps("OBX"); 960 } 961 962 /** 963 * <p> 964 * Returns a non-modifiable List containing all current existing repetitions of OBX. 965 * <p> 966 * <p> 967 * Note that unlike {@link #getOBX()}, this method will not create any reps 968 * if none are already present, so an empty list may be returned. 969 * </p> 970 * 971 */ 972 public java.util.List<OBX> getOBXAll() throws HL7Exception { 973 return getAllAsList("OBX", OBX.class); 974 } 975 976 /** 977 * <p> 978 * Inserts a specific repetition of OBX (Observation/Result) 979 * </p> 980 * 981 * 982 * @see AbstractGroup#insertRepetition(Structure, int) 983 */ 984 public void insertOBX(OBX structure, int rep) throws HL7Exception { 985 super.insertRepetition( "OBX", structure, rep); 986 } 987 988 989 /** 990 * <p> 991 * Inserts a specific repetition of OBX (Observation/Result) 992 * </p> 993 * 994 * 995 * @see AbstractGroup#insertRepetition(Structure, int) 996 */ 997 public OBX insertOBX(int rep) throws HL7Exception { 998 return (OBX)super.insertRepetition("OBX", rep); 999 } 1000 1001 1002 /** 1003 * <p> 1004 * Removes a specific repetition of OBX (Observation/Result) 1005 * </p> 1006 * 1007 * 1008 * @see AbstractGroup#removeRepetition(String, int) 1009 */ 1010 public OBX removeOBX(int rep) throws HL7Exception { 1011 return (OBX)super.removeRepetition("OBX", rep); 1012 } 1013 1014 1015 1016 1017 /** 1018 * <p> 1019 * Returns 1020 * the first repetition of 1021 * AL1 (Patient Allergy Information) - creates it if necessary 1022 * </p> 1023 * 1024 * 1025 */ 1026 public AL1 getAL1() { 1027 return getTyped("AL1", AL1.class); 1028 } 1029 1030 1031 /** 1032 * <p> 1033 * Returns a specific repetition of 1034 * AL1 (Patient Allergy Information) - creates it if necessary 1035 * </p> 1036 * 1037 * 1038 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1039 * @throws HL7Exception if the repetition requested is more than one 1040 * greater than the number of existing repetitions. 1041 */ 1042 public AL1 getAL1(int rep) { 1043 return getTyped("AL1", rep, AL1.class); 1044 } 1045 1046 /** 1047 * <p> 1048 * Returns the number of existing repetitions of AL1 1049 * </p> 1050 * 1051 */ 1052 public int getAL1Reps() { 1053 return getReps("AL1"); 1054 } 1055 1056 /** 1057 * <p> 1058 * Returns a non-modifiable List containing all current existing repetitions of AL1. 1059 * <p> 1060 * <p> 1061 * Note that unlike {@link #getAL1()}, this method will not create any reps 1062 * if none are already present, so an empty list may be returned. 1063 * </p> 1064 * 1065 */ 1066 public java.util.List<AL1> getAL1All() throws HL7Exception { 1067 return getAllAsList("AL1", AL1.class); 1068 } 1069 1070 /** 1071 * <p> 1072 * Inserts a specific repetition of AL1 (Patient Allergy Information) 1073 * </p> 1074 * 1075 * 1076 * @see AbstractGroup#insertRepetition(Structure, int) 1077 */ 1078 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 1079 super.insertRepetition( "AL1", structure, rep); 1080 } 1081 1082 1083 /** 1084 * <p> 1085 * Inserts a specific repetition of AL1 (Patient Allergy Information) 1086 * </p> 1087 * 1088 * 1089 * @see AbstractGroup#insertRepetition(Structure, int) 1090 */ 1091 public AL1 insertAL1(int rep) throws HL7Exception { 1092 return (AL1)super.insertRepetition("AL1", rep); 1093 } 1094 1095 1096 /** 1097 * <p> 1098 * Removes a specific repetition of AL1 (Patient Allergy Information) 1099 * </p> 1100 * 1101 * 1102 * @see AbstractGroup#removeRepetition(String, int) 1103 */ 1104 public AL1 removeAL1(int rep) throws HL7Exception { 1105 return (AL1)super.removeRepetition("AL1", rep); 1106 } 1107 1108 1109 1110 1111 /** 1112 * <p> 1113 * Returns 1114 * the first repetition of 1115 * DG1 (Diagnosis) - creates it if necessary 1116 * </p> 1117 * 1118 * 1119 */ 1120 public DG1 getDG1() { 1121 return getTyped("DG1", DG1.class); 1122 } 1123 1124 1125 /** 1126 * <p> 1127 * Returns a specific repetition of 1128 * DG1 (Diagnosis) - creates it if necessary 1129 * </p> 1130 * 1131 * 1132 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1133 * @throws HL7Exception if the repetition requested is more than one 1134 * greater than the number of existing repetitions. 1135 */ 1136 public DG1 getDG1(int rep) { 1137 return getTyped("DG1", rep, DG1.class); 1138 } 1139 1140 /** 1141 * <p> 1142 * Returns the number of existing repetitions of DG1 1143 * </p> 1144 * 1145 */ 1146 public int getDG1Reps() { 1147 return getReps("DG1"); 1148 } 1149 1150 /** 1151 * <p> 1152 * Returns a non-modifiable List containing all current existing repetitions of DG1. 1153 * <p> 1154 * <p> 1155 * Note that unlike {@link #getDG1()}, this method will not create any reps 1156 * if none are already present, so an empty list may be returned. 1157 * </p> 1158 * 1159 */ 1160 public java.util.List<DG1> getDG1All() throws HL7Exception { 1161 return getAllAsList("DG1", DG1.class); 1162 } 1163 1164 /** 1165 * <p> 1166 * Inserts a specific repetition of DG1 (Diagnosis) 1167 * </p> 1168 * 1169 * 1170 * @see AbstractGroup#insertRepetition(Structure, int) 1171 */ 1172 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 1173 super.insertRepetition( "DG1", structure, rep); 1174 } 1175 1176 1177 /** 1178 * <p> 1179 * Inserts a specific repetition of DG1 (Diagnosis) 1180 * </p> 1181 * 1182 * 1183 * @see AbstractGroup#insertRepetition(Structure, int) 1184 */ 1185 public DG1 insertDG1(int rep) throws HL7Exception { 1186 return (DG1)super.insertRepetition("DG1", rep); 1187 } 1188 1189 1190 /** 1191 * <p> 1192 * Removes a specific repetition of DG1 (Diagnosis) 1193 * </p> 1194 * 1195 * 1196 * @see AbstractGroup#removeRepetition(String, int) 1197 */ 1198 public DG1 removeDG1(int rep) throws HL7Exception { 1199 return (DG1)super.removeRepetition("DG1", rep); 1200 } 1201 1202 1203 1204 1205 /** 1206 * <p> 1207 * Returns 1208 * DRG (Diagnosis Related Group) - creates it if necessary 1209 * </p> 1210 * 1211 * 1212 */ 1213 public DRG getDRG() { 1214 return getTyped("DRG", DRG.class); 1215 } 1216 1217 1218 1219 1220 1221 /** 1222 * <p> 1223 * Returns 1224 * the first repetition of 1225 * PROCEDURE (a Group object) - creates it if necessary 1226 * </p> 1227 * 1228 * 1229 */ 1230 public ADT_A06_PROCEDURE getPROCEDURE() { 1231 return getTyped("PROCEDURE", ADT_A06_PROCEDURE.class); 1232 } 1233 1234 1235 /** 1236 * <p> 1237 * Returns a specific repetition of 1238 * PROCEDURE (a Group object) - creates it if necessary 1239 * </p> 1240 * 1241 * 1242 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1243 * @throws HL7Exception if the repetition requested is more than one 1244 * greater than the number of existing repetitions. 1245 */ 1246 public ADT_A06_PROCEDURE getPROCEDURE(int rep) { 1247 return getTyped("PROCEDURE", rep, ADT_A06_PROCEDURE.class); 1248 } 1249 1250 /** 1251 * <p> 1252 * Returns the number of existing repetitions of PROCEDURE 1253 * </p> 1254 * 1255 */ 1256 public int getPROCEDUREReps() { 1257 return getReps("PROCEDURE"); 1258 } 1259 1260 /** 1261 * <p> 1262 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 1263 * <p> 1264 * <p> 1265 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 1266 * if none are already present, so an empty list may be returned. 1267 * </p> 1268 * 1269 */ 1270 public java.util.List<ADT_A06_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 1271 return getAllAsList("PROCEDURE", ADT_A06_PROCEDURE.class); 1272 } 1273 1274 /** 1275 * <p> 1276 * Inserts a specific repetition of PROCEDURE (a Group object) 1277 * </p> 1278 * 1279 * 1280 * @see AbstractGroup#insertRepetition(Structure, int) 1281 */ 1282 public void insertPROCEDURE(ADT_A06_PROCEDURE structure, int rep) throws HL7Exception { 1283 super.insertRepetition( "PROCEDURE", structure, rep); 1284 } 1285 1286 1287 /** 1288 * <p> 1289 * Inserts a specific repetition of PROCEDURE (a Group object) 1290 * </p> 1291 * 1292 * 1293 * @see AbstractGroup#insertRepetition(Structure, int) 1294 */ 1295 public ADT_A06_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 1296 return (ADT_A06_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 1297 } 1298 1299 1300 /** 1301 * <p> 1302 * Removes a specific repetition of PROCEDURE (a Group object) 1303 * </p> 1304 * 1305 * 1306 * @see AbstractGroup#removeRepetition(String, int) 1307 */ 1308 public ADT_A06_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 1309 return (ADT_A06_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 1310 } 1311 1312 1313 1314 1315 /** 1316 * <p> 1317 * Returns 1318 * the first repetition of 1319 * GT1 (Guarantor) - creates it if necessary 1320 * </p> 1321 * 1322 * 1323 */ 1324 public GT1 getGT1() { 1325 return getTyped("GT1", GT1.class); 1326 } 1327 1328 1329 /** 1330 * <p> 1331 * Returns a specific repetition of 1332 * GT1 (Guarantor) - creates it if necessary 1333 * </p> 1334 * 1335 * 1336 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1337 * @throws HL7Exception if the repetition requested is more than one 1338 * greater than the number of existing repetitions. 1339 */ 1340 public GT1 getGT1(int rep) { 1341 return getTyped("GT1", rep, GT1.class); 1342 } 1343 1344 /** 1345 * <p> 1346 * Returns the number of existing repetitions of GT1 1347 * </p> 1348 * 1349 */ 1350 public int getGT1Reps() { 1351 return getReps("GT1"); 1352 } 1353 1354 /** 1355 * <p> 1356 * Returns a non-modifiable List containing all current existing repetitions of GT1. 1357 * <p> 1358 * <p> 1359 * Note that unlike {@link #getGT1()}, this method will not create any reps 1360 * if none are already present, so an empty list may be returned. 1361 * </p> 1362 * 1363 */ 1364 public java.util.List<GT1> getGT1All() throws HL7Exception { 1365 return getAllAsList("GT1", GT1.class); 1366 } 1367 1368 /** 1369 * <p> 1370 * Inserts a specific repetition of GT1 (Guarantor) 1371 * </p> 1372 * 1373 * 1374 * @see AbstractGroup#insertRepetition(Structure, int) 1375 */ 1376 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 1377 super.insertRepetition( "GT1", structure, rep); 1378 } 1379 1380 1381 /** 1382 * <p> 1383 * Inserts a specific repetition of GT1 (Guarantor) 1384 * </p> 1385 * 1386 * 1387 * @see AbstractGroup#insertRepetition(Structure, int) 1388 */ 1389 public GT1 insertGT1(int rep) throws HL7Exception { 1390 return (GT1)super.insertRepetition("GT1", rep); 1391 } 1392 1393 1394 /** 1395 * <p> 1396 * Removes a specific repetition of GT1 (Guarantor) 1397 * </p> 1398 * 1399 * 1400 * @see AbstractGroup#removeRepetition(String, int) 1401 */ 1402 public GT1 removeGT1(int rep) throws HL7Exception { 1403 return (GT1)super.removeRepetition("GT1", rep); 1404 } 1405 1406 1407 1408 1409 /** 1410 * <p> 1411 * Returns 1412 * the first repetition of 1413 * INSURANCE (a Group object) - creates it if necessary 1414 * </p> 1415 * 1416 * 1417 */ 1418 public ADT_A06_INSURANCE getINSURANCE() { 1419 return getTyped("INSURANCE", ADT_A06_INSURANCE.class); 1420 } 1421 1422 1423 /** 1424 * <p> 1425 * Returns a specific repetition of 1426 * INSURANCE (a Group object) - creates it if necessary 1427 * </p> 1428 * 1429 * 1430 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1431 * @throws HL7Exception if the repetition requested is more than one 1432 * greater than the number of existing repetitions. 1433 */ 1434 public ADT_A06_INSURANCE getINSURANCE(int rep) { 1435 return getTyped("INSURANCE", rep, ADT_A06_INSURANCE.class); 1436 } 1437 1438 /** 1439 * <p> 1440 * Returns the number of existing repetitions of INSURANCE 1441 * </p> 1442 * 1443 */ 1444 public int getINSURANCEReps() { 1445 return getReps("INSURANCE"); 1446 } 1447 1448 /** 1449 * <p> 1450 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 1451 * <p> 1452 * <p> 1453 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 1454 * if none are already present, so an empty list may be returned. 1455 * </p> 1456 * 1457 */ 1458 public java.util.List<ADT_A06_INSURANCE> getINSURANCEAll() throws HL7Exception { 1459 return getAllAsList("INSURANCE", ADT_A06_INSURANCE.class); 1460 } 1461 1462 /** 1463 * <p> 1464 * Inserts a specific repetition of INSURANCE (a Group object) 1465 * </p> 1466 * 1467 * 1468 * @see AbstractGroup#insertRepetition(Structure, int) 1469 */ 1470 public void insertINSURANCE(ADT_A06_INSURANCE structure, int rep) throws HL7Exception { 1471 super.insertRepetition( "INSURANCE", structure, rep); 1472 } 1473 1474 1475 /** 1476 * <p> 1477 * Inserts a specific repetition of INSURANCE (a Group object) 1478 * </p> 1479 * 1480 * 1481 * @see AbstractGroup#insertRepetition(Structure, int) 1482 */ 1483 public ADT_A06_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 1484 return (ADT_A06_INSURANCE)super.insertRepetition("INSURANCE", rep); 1485 } 1486 1487 1488 /** 1489 * <p> 1490 * Removes a specific repetition of INSURANCE (a Group object) 1491 * </p> 1492 * 1493 * 1494 * @see AbstractGroup#removeRepetition(String, int) 1495 */ 1496 public ADT_A06_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 1497 return (ADT_A06_INSURANCE)super.removeRepetition("INSURANCE", rep); 1498 } 1499 1500 1501 1502 1503 /** 1504 * <p> 1505 * Returns 1506 * ACC (Accident) - creates it if necessary 1507 * </p> 1508 * 1509 * 1510 */ 1511 public ACC getACC() { 1512 return getTyped("ACC", ACC.class); 1513 } 1514 1515 1516 1517 1518 1519 /** 1520 * <p> 1521 * Returns 1522 * UB1 (UB82) - creates it if necessary 1523 * </p> 1524 * 1525 * 1526 */ 1527 public UB1 getUB1() { 1528 return getTyped("UB1", UB1.class); 1529 } 1530 1531 1532 1533 1534 1535 /** 1536 * <p> 1537 * Returns 1538 * UB2 (UB92 Data) - creates it if necessary 1539 * </p> 1540 * 1541 * 1542 */ 1543 public UB2 getUB2() { 1544 return getTyped("UB2", UB2.class); 1545 } 1546 1547 1548 1549 1550 } 1551