1 /* 2 * This class is an auto-generated source file for a HAPI 3 * HL7 v2.x standard structure class. 4 * 5 * For more information, visit: http://hl7api.sourceforge.net/ 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 1.1 8 * (the "License"); you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 10 * Software distributed under the License is distributed on an "AS IS" basis, 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 12 * specific language governing rights and limitations under the License. 13 * 14 * The Original Code is "[file_name]". Description: 15 * "[one_line_description]" 16 * 17 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 18 * 2012. All Rights Reserved. 19 * 20 * Contributor(s): ______________________________________. 21 * 22 * Alternatively, the contents of this file may be used under the terms of the 23 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 24 * applicable instead of those above. If you wish to allow use of your version of this 25 * file only under the terms of the GPL and not to allow others to use your version 26 * of this file under the MPL, indicate your decision by deleting the provisions above 27 * and replace them with the notice and other provisions required by the GPL License. 28 * If you do not delete the provisions above, a recipient may use your version of 29 * this file under either the MPL or the GPL. 30 * 31 */ 32 33 34 package ca.uhn.hl7v2.model.v28.message; 35 36 import ca.uhn.hl7v2.model.v28.group.*; 37 import ca.uhn.hl7v2.model.v28.segment.*; 38 39 import ca.uhn.hl7v2.HL7Exception; 40 import ca.uhn.hl7v2.parser.ModelClassFactory; 41 import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 42 import ca.uhn.hl7v2.model.*; 43 44 45 /** 46 * <p>Represents a DFT_P11 message structure (see chapter 6.4.8). 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_P11_COMMON_ORDER (a Group object) <b>optional repeating</b> </li> 63 * <li>15: DG1 (Diagnosis) <b>optional repeating</b> </li> 64 * <li>16: DRG (Diagnosis Related Group) <b>optional </b> </li> 65 * <li>17: GT1 (Guarantor) <b>optional repeating</b> </li> 66 * <li>18: DFT_P11_INSURANCE (a Group object) <b>optional repeating</b> </li> 67 * <li>19: ACC (Accident) <b>optional </b> </li> 68 * <li>20: DFT_P11_FINANCIAL (a Group object) <b> repeating</b> </li> 69 * </ul> 70 */ 71 //@SuppressWarnings("unused") 72 public class DFT_P11 extends AbstractMessage { 73 74 /** 75 * Creates a new DFT_P11 message with DefaultModelClassFactory. 76 */ 77 public DFT_P11() { 78 this(new DefaultModelClassFactory()); 79 } 80 81 /** 82 * Creates a new DFT_P11 message with custom ModelClassFactory. 83 */ 84 public DFT_P11(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_P11_COMMON_ORDER.class, false, true); 105 this.add(DG1.class, false, true); 106 this.add(DRG.class, false, false); 107 this.add(GT1.class, false, true); 108 this.add(DFT_P11_INSURANCE.class, false, true); 109 this.add(ACC.class, false, false); 110 this.add(DFT_P11_FINANCIAL.class, true, true); 111 } catch(HL7Exception e) { 112 log.error("Unexpected error creating DFT_P11 - this is probably a bug in the source code generator.", e); 113 } 114 } 115 116 117 /** 118 * Returns "2.8" 119 */ 120 public String getVersion() { 121 return "2.8"; 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_P11_COMMON_ORDER getCOMMON_ORDER() { 813 return getTyped("COMMON_ORDER", DFT_P11_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_P11_COMMON_ORDER getCOMMON_ORDER(int rep) { 829 return getTyped("COMMON_ORDER", rep, DFT_P11_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_P11_COMMON_ORDER> getCOMMON_ORDERAll() throws HL7Exception { 853 return getAllAsList("COMMON_ORDER", DFT_P11_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_P11_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_P11_COMMON_ORDER insertCOMMON_ORDER(int rep) throws HL7Exception { 878 return (DFT_P11_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_P11_COMMON_ORDER removeCOMMON_ORDER(int rep) throws HL7Exception { 891 return (DFT_P11_COMMON_ORDER)super.removeRepetition("COMMON_ORDER", rep); 892 } 893 894 895 896 897 /** 898 * <p> 899 * Returns 900 * the first repetition of 901 * DG1 (Diagnosis) - creates it if necessary 902 * </p> 903 * 904 * 905 */ 906 public DG1 getDG1() { 907 return getTyped("DG1", DG1.class); 908 } 909 910 911 /** 912 * <p> 913 * Returns a specific repetition of 914 * DG1 (Diagnosis) - 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 DG1 getDG1(int rep) { 923 return getTyped("DG1", rep, DG1.class); 924 } 925 926 /** 927 * <p> 928 * Returns the number of existing repetitions of DG1 929 * </p> 930 * 931 */ 932 public int getDG1Reps() { 933 return getReps("DG1"); 934 } 935 936 /** 937 * <p> 938 * Returns a non-modifiable List containing all current existing repetitions of DG1. 939 * <p> 940 * <p> 941 * Note that unlike {@link #getDG1()}, 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<DG1> getDG1All() throws HL7Exception { 947 return getAllAsList("DG1", DG1.class); 948 } 949 950 /** 951 * <p> 952 * Inserts a specific repetition of DG1 (Diagnosis) 953 * </p> 954 * 955 * 956 * @see AbstractGroup#insertRepetition(Structure, int) 957 */ 958 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 959 super.insertRepetition( "DG1", structure, rep); 960 } 961 962 963 /** 964 * <p> 965 * Inserts a specific repetition of DG1 (Diagnosis) 966 * </p> 967 * 968 * 969 * @see AbstractGroup#insertRepetition(Structure, int) 970 */ 971 public DG1 insertDG1(int rep) throws HL7Exception { 972 return (DG1)super.insertRepetition("DG1", rep); 973 } 974 975 976 /** 977 * <p> 978 * Removes a specific repetition of DG1 (Diagnosis) 979 * </p> 980 * 981 * 982 * @see AbstractGroup#removeRepetition(String, int) 983 */ 984 public DG1 removeDG1(int rep) throws HL7Exception { 985 return (DG1)super.removeRepetition("DG1", rep); 986 } 987 988 989 990 991 /** 992 * <p> 993 * Returns 994 * DRG (Diagnosis Related Group) - creates it if necessary 995 * </p> 996 * 997 * 998 */ 999 public DRG getDRG() { 1000 return getTyped("DRG", DRG.class); 1001 } 1002 1003 1004 1005 1006 1007 /** 1008 * <p> 1009 * Returns 1010 * the first repetition of 1011 * GT1 (Guarantor) - creates it if necessary 1012 * </p> 1013 * 1014 * 1015 */ 1016 public GT1 getGT1() { 1017 return getTyped("GT1", GT1.class); 1018 } 1019 1020 1021 /** 1022 * <p> 1023 * Returns a specific repetition of 1024 * GT1 (Guarantor) - creates it if necessary 1025 * </p> 1026 * 1027 * 1028 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1029 * @throws HL7Exception if the repetition requested is more than one 1030 * greater than the number of existing repetitions. 1031 */ 1032 public GT1 getGT1(int rep) { 1033 return getTyped("GT1", rep, GT1.class); 1034 } 1035 1036 /** 1037 * <p> 1038 * Returns the number of existing repetitions of GT1 1039 * </p> 1040 * 1041 */ 1042 public int getGT1Reps() { 1043 return getReps("GT1"); 1044 } 1045 1046 /** 1047 * <p> 1048 * Returns a non-modifiable List containing all current existing repetitions of GT1. 1049 * <p> 1050 * <p> 1051 * Note that unlike {@link #getGT1()}, this method will not create any reps 1052 * if none are already present, so an empty list may be returned. 1053 * </p> 1054 * 1055 */ 1056 public java.util.List<GT1> getGT1All() throws HL7Exception { 1057 return getAllAsList("GT1", GT1.class); 1058 } 1059 1060 /** 1061 * <p> 1062 * Inserts a specific repetition of GT1 (Guarantor) 1063 * </p> 1064 * 1065 * 1066 * @see AbstractGroup#insertRepetition(Structure, int) 1067 */ 1068 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 1069 super.insertRepetition( "GT1", structure, rep); 1070 } 1071 1072 1073 /** 1074 * <p> 1075 * Inserts a specific repetition of GT1 (Guarantor) 1076 * </p> 1077 * 1078 * 1079 * @see AbstractGroup#insertRepetition(Structure, int) 1080 */ 1081 public GT1 insertGT1(int rep) throws HL7Exception { 1082 return (GT1)super.insertRepetition("GT1", rep); 1083 } 1084 1085 1086 /** 1087 * <p> 1088 * Removes a specific repetition of GT1 (Guarantor) 1089 * </p> 1090 * 1091 * 1092 * @see AbstractGroup#removeRepetition(String, int) 1093 */ 1094 public GT1 removeGT1(int rep) throws HL7Exception { 1095 return (GT1)super.removeRepetition("GT1", rep); 1096 } 1097 1098 1099 1100 1101 /** 1102 * <p> 1103 * Returns 1104 * the first repetition of 1105 * INSURANCE (a Group object) - creates it if necessary 1106 * </p> 1107 * 1108 * 1109 */ 1110 public DFT_P11_INSURANCE getINSURANCE() { 1111 return getTyped("INSURANCE", DFT_P11_INSURANCE.class); 1112 } 1113 1114 1115 /** 1116 * <p> 1117 * Returns a specific repetition of 1118 * INSURANCE (a Group object) - 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 DFT_P11_INSURANCE getINSURANCE(int rep) { 1127 return getTyped("INSURANCE", rep, DFT_P11_INSURANCE.class); 1128 } 1129 1130 /** 1131 * <p> 1132 * Returns the number of existing repetitions of INSURANCE 1133 * </p> 1134 * 1135 */ 1136 public int getINSURANCEReps() { 1137 return getReps("INSURANCE"); 1138 } 1139 1140 /** 1141 * <p> 1142 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 1143 * <p> 1144 * <p> 1145 * Note that unlike {@link #getINSURANCE()}, 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<DFT_P11_INSURANCE> getINSURANCEAll() throws HL7Exception { 1151 return getAllAsList("INSURANCE", DFT_P11_INSURANCE.class); 1152 } 1153 1154 /** 1155 * <p> 1156 * Inserts a specific repetition of INSURANCE (a Group object) 1157 * </p> 1158 * 1159 * 1160 * @see AbstractGroup#insertRepetition(Structure, int) 1161 */ 1162 public void insertINSURANCE(DFT_P11_INSURANCE structure, int rep) throws HL7Exception { 1163 super.insertRepetition( "INSURANCE", structure, rep); 1164 } 1165 1166 1167 /** 1168 * <p> 1169 * Inserts a specific repetition of INSURANCE (a Group object) 1170 * </p> 1171 * 1172 * 1173 * @see AbstractGroup#insertRepetition(Structure, int) 1174 */ 1175 public DFT_P11_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 1176 return (DFT_P11_INSURANCE)super.insertRepetition("INSURANCE", rep); 1177 } 1178 1179 1180 /** 1181 * <p> 1182 * Removes a specific repetition of INSURANCE (a Group object) 1183 * </p> 1184 * 1185 * 1186 * @see AbstractGroup#removeRepetition(String, int) 1187 */ 1188 public DFT_P11_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 1189 return (DFT_P11_INSURANCE)super.removeRepetition("INSURANCE", rep); 1190 } 1191 1192 1193 1194 1195 /** 1196 * <p> 1197 * Returns 1198 * ACC (Accident) - creates it if necessary 1199 * </p> 1200 * 1201 * 1202 */ 1203 public ACC getACC() { 1204 return getTyped("ACC", ACC.class); 1205 } 1206 1207 1208 1209 1210 1211 /** 1212 * <p> 1213 * Returns 1214 * the first repetition of 1215 * FINANCIAL (a Group object) - creates it if necessary 1216 * </p> 1217 * 1218 * 1219 */ 1220 public DFT_P11_FINANCIAL getFINANCIAL() { 1221 return getTyped("FINANCIAL", DFT_P11_FINANCIAL.class); 1222 } 1223 1224 1225 /** 1226 * <p> 1227 * Returns a specific repetition of 1228 * FINANCIAL (a Group object) - creates it if necessary 1229 * </p> 1230 * 1231 * 1232 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1233 * @throws HL7Exception if the repetition requested is more than one 1234 * greater than the number of existing repetitions. 1235 */ 1236 public DFT_P11_FINANCIAL getFINANCIAL(int rep) { 1237 return getTyped("FINANCIAL", rep, DFT_P11_FINANCIAL.class); 1238 } 1239 1240 /** 1241 * <p> 1242 * Returns the number of existing repetitions of FINANCIAL 1243 * </p> 1244 * 1245 */ 1246 public int getFINANCIALReps() { 1247 return getReps("FINANCIAL"); 1248 } 1249 1250 /** 1251 * <p> 1252 * Returns a non-modifiable List containing all current existing repetitions of FINANCIAL. 1253 * <p> 1254 * <p> 1255 * Note that unlike {@link #getFINANCIAL()}, this method will not create any reps 1256 * if none are already present, so an empty list may be returned. 1257 * </p> 1258 * 1259 */ 1260 public java.util.List<DFT_P11_FINANCIAL> getFINANCIALAll() throws HL7Exception { 1261 return getAllAsList("FINANCIAL", DFT_P11_FINANCIAL.class); 1262 } 1263 1264 /** 1265 * <p> 1266 * Inserts a specific repetition of FINANCIAL (a Group object) 1267 * </p> 1268 * 1269 * 1270 * @see AbstractGroup#insertRepetition(Structure, int) 1271 */ 1272 public void insertFINANCIAL(DFT_P11_FINANCIAL structure, int rep) throws HL7Exception { 1273 super.insertRepetition( "FINANCIAL", structure, rep); 1274 } 1275 1276 1277 /** 1278 * <p> 1279 * Inserts a specific repetition of FINANCIAL (a Group object) 1280 * </p> 1281 * 1282 * 1283 * @see AbstractGroup#insertRepetition(Structure, int) 1284 */ 1285 public DFT_P11_FINANCIAL insertFINANCIAL(int rep) throws HL7Exception { 1286 return (DFT_P11_FINANCIAL)super.insertRepetition("FINANCIAL", rep); 1287 } 1288 1289 1290 /** 1291 * <p> 1292 * Removes a specific repetition of FINANCIAL (a Group object) 1293 * </p> 1294 * 1295 * 1296 * @see AbstractGroup#removeRepetition(String, int) 1297 */ 1298 public DFT_P11_FINANCIAL removeFINANCIAL(int rep) throws HL7Exception { 1299 return (DFT_P11_FINANCIAL)super.removeRepetition("FINANCIAL", rep); 1300 } 1301 1302 1303 1304 } 1305