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