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