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.v25.message; 035 036import ca.uhn.hl7v2.model.v25.group.*; 037import ca.uhn.hl7v2.model.v25.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 DFT_P11 message structure (see chapter 6.4.8). 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: PV1 (Patient Visit) <b>optional </b> </li> 056 * <li>8: PV2 (Patient Visit - Additional Information) <b>optional </b> </li> 057 * <li>9: ROL (Role) <b>optional repeating</b> </li> 058 * <li>10: DB1 (Disability) <b>optional repeating</b> </li> 059 * <li>11: DFT_P11_COMMON_ORDER (a Group object) <b>optional repeating</b> </li> 060 * <li>12: DG1 (Diagnosis) <b>optional repeating</b> </li> 061 * <li>13: DRG (Diagnosis Related Group) <b>optional </b> </li> 062 * <li>14: GT1 (Guarantor) <b>optional repeating</b> </li> 063 * <li>15: DFT_P11_INSURANCE (a Group object) <b>optional repeating</b> </li> 064 * <li>16: ACC (Accident) <b>optional </b> </li> 065 * <li>17: DFT_P11_FINANCIAL (a Group object) <b> repeating</b> </li> 066 * </ul> 067 */ 068//@SuppressWarnings("unused") 069public class DFT_P11 extends AbstractMessage { 070 071 /** 072 * Creates a new DFT_P11 message with DefaultModelClassFactory. 073 */ 074 public DFT_P11() { 075 this(new DefaultModelClassFactory()); 076 } 077 078 /** 079 * Creates a new DFT_P11 message with custom ModelClassFactory. 080 */ 081 public DFT_P11(ModelClassFactory factory) { 082 super(factory); 083 init(factory); 084 } 085 086 private void init(ModelClassFactory factory) { 087 try { 088 this.add(MSH.class, true, false); 089 this.add(SFT.class, false, true); 090 this.add(EVN.class, true, false); 091 this.add(PID.class, true, false); 092 this.add(PD1.class, false, false); 093 this.add(ROL.class, false, true); 094 this.add(PV1.class, false, false); 095 this.add(PV2.class, false, false); 096 this.add(ROL.class, false, true); 097 this.add(DB1.class, false, true); 098 this.add(DFT_P11_COMMON_ORDER.class, false, true); 099 this.add(DG1.class, false, true); 100 this.add(DRG.class, false, false); 101 this.add(GT1.class, false, true); 102 this.add(DFT_P11_INSURANCE.class, false, true); 103 this.add(ACC.class, false, false); 104 this.add(DFT_P11_FINANCIAL.class, true, true); 105 } catch(HL7Exception e) { 106 log.error("Unexpected error creating DFT_P11 - this is probably a bug in the source code generator.", e); 107 } 108 } 109 110 111 /** 112 * Returns "2.5" 113 */ 114 public String getVersion() { 115 return "2.5"; 116 } 117 118 119 120 121 /** 122 * <p> 123 * Returns 124 * MSH (Message Header) - creates it if necessary 125 * </p> 126 * 127 * 128 */ 129 public MSH getMSH() { 130 return getTyped("MSH", MSH.class); 131 } 132 133 134 135 136 137 /** 138 * <p> 139 * Returns 140 * the first repetition of 141 * SFT (Software Segment) - creates it if necessary 142 * </p> 143 * 144 * 145 */ 146 public SFT getSFT() { 147 return getTyped("SFT", SFT.class); 148 } 149 150 151 /** 152 * <p> 153 * Returns a specific repetition of 154 * SFT (Software Segment) - creates it if necessary 155 * </p> 156 * 157 * 158 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 159 * @throws HL7Exception if the repetition requested is more than one 160 * greater than the number of existing repetitions. 161 */ 162 public SFT getSFT(int rep) { 163 return getTyped("SFT", rep, SFT.class); 164 } 165 166 /** 167 * <p> 168 * Returns the number of existing repetitions of SFT 169 * </p> 170 * 171 */ 172 public int getSFTReps() { 173 return getReps("SFT"); 174 } 175 176 /** 177 * <p> 178 * Returns a non-modifiable List containing all current existing repetitions of SFT. 179 * <p> 180 * <p> 181 * Note that unlike {@link #getSFT()}, this method will not create any reps 182 * if none are already present, so an empty list may be returned. 183 * </p> 184 * 185 */ 186 public java.util.List<SFT> getSFTAll() throws HL7Exception { 187 return getAllAsList("SFT", SFT.class); 188 } 189 190 /** 191 * <p> 192 * Inserts a specific repetition of SFT (Software Segment) 193 * </p> 194 * 195 * 196 * @see AbstractGroup#insertRepetition(Structure, int) 197 */ 198 public void insertSFT(SFT structure, int rep) throws HL7Exception { 199 super.insertRepetition( "SFT", structure, rep); 200 } 201 202 203 /** 204 * <p> 205 * Inserts a specific repetition of SFT (Software Segment) 206 * </p> 207 * 208 * 209 * @see AbstractGroup#insertRepetition(Structure, int) 210 */ 211 public SFT insertSFT(int rep) throws HL7Exception { 212 return (SFT)super.insertRepetition("SFT", rep); 213 } 214 215 216 /** 217 * <p> 218 * Removes a specific repetition of SFT (Software Segment) 219 * </p> 220 * 221 * 222 * @see AbstractGroup#removeRepetition(String, int) 223 */ 224 public SFT removeSFT(int rep) throws HL7Exception { 225 return (SFT)super.removeRepetition("SFT", rep); 226 } 227 228 229 230 231 /** 232 * <p> 233 * Returns 234 * EVN (Event Type) - creates it if necessary 235 * </p> 236 * 237 * 238 */ 239 public EVN getEVN() { 240 return getTyped("EVN", EVN.class); 241 } 242 243 244 245 246 247 /** 248 * <p> 249 * Returns 250 * PID (Patient Identification) - creates it if necessary 251 * </p> 252 * 253 * 254 */ 255 public PID getPID() { 256 return getTyped("PID", PID.class); 257 } 258 259 260 261 262 263 /** 264 * <p> 265 * Returns 266 * PD1 (Patient Additional Demographic) - creates it if necessary 267 * </p> 268 * 269 * 270 */ 271 public PD1 getPD1() { 272 return getTyped("PD1", PD1.class); 273 } 274 275 276 277 278 279 /** 280 * <p> 281 * Returns 282 * the first repetition of 283 * ROL (Role) - creates it if necessary 284 * </p> 285 * 286 * 287 */ 288 public ROL getROL() { 289 return getTyped("ROL", ROL.class); 290 } 291 292 293 /** 294 * <p> 295 * Returns a specific repetition of 296 * ROL (Role) - creates it if necessary 297 * </p> 298 * 299 * 300 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 301 * @throws HL7Exception if the repetition requested is more than one 302 * greater than the number of existing repetitions. 303 */ 304 public ROL getROL(int rep) { 305 return getTyped("ROL", rep, ROL.class); 306 } 307 308 /** 309 * <p> 310 * Returns the number of existing repetitions of ROL 311 * </p> 312 * 313 */ 314 public int getROLReps() { 315 return getReps("ROL"); 316 } 317 318 /** 319 * <p> 320 * Returns a non-modifiable List containing all current existing repetitions of ROL. 321 * <p> 322 * <p> 323 * Note that unlike {@link #getROL()}, this method will not create any reps 324 * if none are already present, so an empty list may be returned. 325 * </p> 326 * 327 */ 328 public java.util.List<ROL> getROLAll() throws HL7Exception { 329 return getAllAsList("ROL", ROL.class); 330 } 331 332 /** 333 * <p> 334 * Inserts a specific repetition of ROL (Role) 335 * </p> 336 * 337 * 338 * @see AbstractGroup#insertRepetition(Structure, int) 339 */ 340 public void insertROL(ROL structure, int rep) throws HL7Exception { 341 super.insertRepetition( "ROL", structure, rep); 342 } 343 344 345 /** 346 * <p> 347 * Inserts a specific repetition of ROL (Role) 348 * </p> 349 * 350 * 351 * @see AbstractGroup#insertRepetition(Structure, int) 352 */ 353 public ROL insertROL(int rep) throws HL7Exception { 354 return (ROL)super.insertRepetition("ROL", rep); 355 } 356 357 358 /** 359 * <p> 360 * Removes a specific repetition of ROL (Role) 361 * </p> 362 * 363 * 364 * @see AbstractGroup#removeRepetition(String, int) 365 */ 366 public ROL removeROL(int rep) throws HL7Exception { 367 return (ROL)super.removeRepetition("ROL", rep); 368 } 369 370 371 372 373 /** 374 * <p> 375 * Returns 376 * PV1 (Patient Visit) - creates it if necessary 377 * </p> 378 * 379 * 380 */ 381 public PV1 getPV1() { 382 return getTyped("PV1", PV1.class); 383 } 384 385 386 387 388 389 /** 390 * <p> 391 * Returns 392 * PV2 (Patient Visit - Additional Information) - creates it if necessary 393 * </p> 394 * 395 * 396 */ 397 public PV2 getPV2() { 398 return getTyped("PV2", PV2.class); 399 } 400 401 402 403 404 405 /** 406 * <p> 407 * Returns 408 * the first repetition of 409 * ROL2 (Role) - creates it if necessary 410 * </p> 411 * 412 * 413 */ 414 public ROL getROL2() { 415 return getTyped("ROL2", ROL.class); 416 } 417 418 419 /** 420 * <p> 421 * Returns a specific repetition of 422 * ROL2 (Role) - creates it if necessary 423 * </p> 424 * 425 * 426 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 427 * @throws HL7Exception if the repetition requested is more than one 428 * greater than the number of existing repetitions. 429 */ 430 public ROL getROL2(int rep) { 431 return getTyped("ROL2", rep, ROL.class); 432 } 433 434 /** 435 * <p> 436 * Returns the number of existing repetitions of ROL2 437 * </p> 438 * 439 */ 440 public int getROL2Reps() { 441 return getReps("ROL2"); 442 } 443 444 /** 445 * <p> 446 * Returns a non-modifiable List containing all current existing repetitions of ROL2. 447 * <p> 448 * <p> 449 * Note that unlike {@link #getROL2()}, this method will not create any reps 450 * if none are already present, so an empty list may be returned. 451 * </p> 452 * 453 */ 454 public java.util.List<ROL> getROL2All() throws HL7Exception { 455 return getAllAsList("ROL2", ROL.class); 456 } 457 458 /** 459 * <p> 460 * Inserts a specific repetition of ROL2 (Role) 461 * </p> 462 * 463 * 464 * @see AbstractGroup#insertRepetition(Structure, int) 465 */ 466 public void insertROL2(ROL structure, int rep) throws HL7Exception { 467 super.insertRepetition( "ROL2", structure, rep); 468 } 469 470 471 /** 472 * <p> 473 * Inserts a specific repetition of ROL2 (Role) 474 * </p> 475 * 476 * 477 * @see AbstractGroup#insertRepetition(Structure, int) 478 */ 479 public ROL insertROL2(int rep) throws HL7Exception { 480 return (ROL)super.insertRepetition("ROL2", rep); 481 } 482 483 484 /** 485 * <p> 486 * Removes a specific repetition of ROL2 (Role) 487 * </p> 488 * 489 * 490 * @see AbstractGroup#removeRepetition(String, int) 491 */ 492 public ROL removeROL2(int rep) throws HL7Exception { 493 return (ROL)super.removeRepetition("ROL2", rep); 494 } 495 496 497 498 499 /** 500 * <p> 501 * Returns 502 * the first repetition of 503 * DB1 (Disability) - creates it if necessary 504 * </p> 505 * 506 * 507 */ 508 public DB1 getDB1() { 509 return getTyped("DB1", DB1.class); 510 } 511 512 513 /** 514 * <p> 515 * Returns a specific repetition of 516 * DB1 (Disability) - creates it if necessary 517 * </p> 518 * 519 * 520 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 521 * @throws HL7Exception if the repetition requested is more than one 522 * greater than the number of existing repetitions. 523 */ 524 public DB1 getDB1(int rep) { 525 return getTyped("DB1", rep, DB1.class); 526 } 527 528 /** 529 * <p> 530 * Returns the number of existing repetitions of DB1 531 * </p> 532 * 533 */ 534 public int getDB1Reps() { 535 return getReps("DB1"); 536 } 537 538 /** 539 * <p> 540 * Returns a non-modifiable List containing all current existing repetitions of DB1. 541 * <p> 542 * <p> 543 * Note that unlike {@link #getDB1()}, this method will not create any reps 544 * if none are already present, so an empty list may be returned. 545 * </p> 546 * 547 */ 548 public java.util.List<DB1> getDB1All() throws HL7Exception { 549 return getAllAsList("DB1", DB1.class); 550 } 551 552 /** 553 * <p> 554 * Inserts a specific repetition of DB1 (Disability) 555 * </p> 556 * 557 * 558 * @see AbstractGroup#insertRepetition(Structure, int) 559 */ 560 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 561 super.insertRepetition( "DB1", structure, rep); 562 } 563 564 565 /** 566 * <p> 567 * Inserts a specific repetition of DB1 (Disability) 568 * </p> 569 * 570 * 571 * @see AbstractGroup#insertRepetition(Structure, int) 572 */ 573 public DB1 insertDB1(int rep) throws HL7Exception { 574 return (DB1)super.insertRepetition("DB1", rep); 575 } 576 577 578 /** 579 * <p> 580 * Removes a specific repetition of DB1 (Disability) 581 * </p> 582 * 583 * 584 * @see AbstractGroup#removeRepetition(String, int) 585 */ 586 public DB1 removeDB1(int rep) throws HL7Exception { 587 return (DB1)super.removeRepetition("DB1", rep); 588 } 589 590 591 592 593 /** 594 * <p> 595 * Returns 596 * the first repetition of 597 * COMMON_ORDER (a Group object) - creates it if necessary 598 * </p> 599 * 600 * 601 */ 602 public DFT_P11_COMMON_ORDER getCOMMON_ORDER() { 603 return getTyped("COMMON_ORDER", DFT_P11_COMMON_ORDER.class); 604 } 605 606 607 /** 608 * <p> 609 * Returns a specific repetition of 610 * COMMON_ORDER (a Group object) - creates it if necessary 611 * </p> 612 * 613 * 614 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 615 * @throws HL7Exception if the repetition requested is more than one 616 * greater than the number of existing repetitions. 617 */ 618 public DFT_P11_COMMON_ORDER getCOMMON_ORDER(int rep) { 619 return getTyped("COMMON_ORDER", rep, DFT_P11_COMMON_ORDER.class); 620 } 621 622 /** 623 * <p> 624 * Returns the number of existing repetitions of COMMON_ORDER 625 * </p> 626 * 627 */ 628 public int getCOMMON_ORDERReps() { 629 return getReps("COMMON_ORDER"); 630 } 631 632 /** 633 * <p> 634 * Returns a non-modifiable List containing all current existing repetitions of COMMON_ORDER. 635 * <p> 636 * <p> 637 * Note that unlike {@link #getCOMMON_ORDER()}, this method will not create any reps 638 * if none are already present, so an empty list may be returned. 639 * </p> 640 * 641 */ 642 public java.util.List<DFT_P11_COMMON_ORDER> getCOMMON_ORDERAll() throws HL7Exception { 643 return getAllAsList("COMMON_ORDER", DFT_P11_COMMON_ORDER.class); 644 } 645 646 /** 647 * <p> 648 * Inserts a specific repetition of COMMON_ORDER (a Group object) 649 * </p> 650 * 651 * 652 * @see AbstractGroup#insertRepetition(Structure, int) 653 */ 654 public void insertCOMMON_ORDER(DFT_P11_COMMON_ORDER structure, int rep) throws HL7Exception { 655 super.insertRepetition( "COMMON_ORDER", structure, rep); 656 } 657 658 659 /** 660 * <p> 661 * Inserts a specific repetition of COMMON_ORDER (a Group object) 662 * </p> 663 * 664 * 665 * @see AbstractGroup#insertRepetition(Structure, int) 666 */ 667 public DFT_P11_COMMON_ORDER insertCOMMON_ORDER(int rep) throws HL7Exception { 668 return (DFT_P11_COMMON_ORDER)super.insertRepetition("COMMON_ORDER", rep); 669 } 670 671 672 /** 673 * <p> 674 * Removes a specific repetition of COMMON_ORDER (a Group object) 675 * </p> 676 * 677 * 678 * @see AbstractGroup#removeRepetition(String, int) 679 */ 680 public DFT_P11_COMMON_ORDER removeCOMMON_ORDER(int rep) throws HL7Exception { 681 return (DFT_P11_COMMON_ORDER)super.removeRepetition("COMMON_ORDER", rep); 682 } 683 684 685 686 687 /** 688 * <p> 689 * Returns 690 * the first repetition of 691 * DG1 (Diagnosis) - creates it if necessary 692 * </p> 693 * 694 * 695 */ 696 public DG1 getDG1() { 697 return getTyped("DG1", DG1.class); 698 } 699 700 701 /** 702 * <p> 703 * Returns a specific repetition of 704 * DG1 (Diagnosis) - creates it if necessary 705 * </p> 706 * 707 * 708 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 709 * @throws HL7Exception if the repetition requested is more than one 710 * greater than the number of existing repetitions. 711 */ 712 public DG1 getDG1(int rep) { 713 return getTyped("DG1", rep, DG1.class); 714 } 715 716 /** 717 * <p> 718 * Returns the number of existing repetitions of DG1 719 * </p> 720 * 721 */ 722 public int getDG1Reps() { 723 return getReps("DG1"); 724 } 725 726 /** 727 * <p> 728 * Returns a non-modifiable List containing all current existing repetitions of DG1. 729 * <p> 730 * <p> 731 * Note that unlike {@link #getDG1()}, this method will not create any reps 732 * if none are already present, so an empty list may be returned. 733 * </p> 734 * 735 */ 736 public java.util.List<DG1> getDG1All() throws HL7Exception { 737 return getAllAsList("DG1", DG1.class); 738 } 739 740 /** 741 * <p> 742 * Inserts a specific repetition of DG1 (Diagnosis) 743 * </p> 744 * 745 * 746 * @see AbstractGroup#insertRepetition(Structure, int) 747 */ 748 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 749 super.insertRepetition( "DG1", structure, rep); 750 } 751 752 753 /** 754 * <p> 755 * Inserts a specific repetition of DG1 (Diagnosis) 756 * </p> 757 * 758 * 759 * @see AbstractGroup#insertRepetition(Structure, int) 760 */ 761 public DG1 insertDG1(int rep) throws HL7Exception { 762 return (DG1)super.insertRepetition("DG1", rep); 763 } 764 765 766 /** 767 * <p> 768 * Removes a specific repetition of DG1 (Diagnosis) 769 * </p> 770 * 771 * 772 * @see AbstractGroup#removeRepetition(String, int) 773 */ 774 public DG1 removeDG1(int rep) throws HL7Exception { 775 return (DG1)super.removeRepetition("DG1", rep); 776 } 777 778 779 780 781 /** 782 * <p> 783 * Returns 784 * DRG (Diagnosis Related Group) - creates it if necessary 785 * </p> 786 * 787 * 788 */ 789 public DRG getDRG() { 790 return getTyped("DRG", DRG.class); 791 } 792 793 794 795 796 797 /** 798 * <p> 799 * Returns 800 * the first repetition of 801 * GT1 (Guarantor) - creates it if necessary 802 * </p> 803 * 804 * 805 */ 806 public GT1 getGT1() { 807 return getTyped("GT1", GT1.class); 808 } 809 810 811 /** 812 * <p> 813 * Returns a specific repetition of 814 * GT1 (Guarantor) - creates it if necessary 815 * </p> 816 * 817 * 818 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 819 * @throws HL7Exception if the repetition requested is more than one 820 * greater than the number of existing repetitions. 821 */ 822 public GT1 getGT1(int rep) { 823 return getTyped("GT1", rep, GT1.class); 824 } 825 826 /** 827 * <p> 828 * Returns the number of existing repetitions of GT1 829 * </p> 830 * 831 */ 832 public int getGT1Reps() { 833 return getReps("GT1"); 834 } 835 836 /** 837 * <p> 838 * Returns a non-modifiable List containing all current existing repetitions of GT1. 839 * <p> 840 * <p> 841 * Note that unlike {@link #getGT1()}, this method will not create any reps 842 * if none are already present, so an empty list may be returned. 843 * </p> 844 * 845 */ 846 public java.util.List<GT1> getGT1All() throws HL7Exception { 847 return getAllAsList("GT1", GT1.class); 848 } 849 850 /** 851 * <p> 852 * Inserts a specific repetition of GT1 (Guarantor) 853 * </p> 854 * 855 * 856 * @see AbstractGroup#insertRepetition(Structure, int) 857 */ 858 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 859 super.insertRepetition( "GT1", structure, rep); 860 } 861 862 863 /** 864 * <p> 865 * Inserts a specific repetition of GT1 (Guarantor) 866 * </p> 867 * 868 * 869 * @see AbstractGroup#insertRepetition(Structure, int) 870 */ 871 public GT1 insertGT1(int rep) throws HL7Exception { 872 return (GT1)super.insertRepetition("GT1", rep); 873 } 874 875 876 /** 877 * <p> 878 * Removes a specific repetition of GT1 (Guarantor) 879 * </p> 880 * 881 * 882 * @see AbstractGroup#removeRepetition(String, int) 883 */ 884 public GT1 removeGT1(int rep) throws HL7Exception { 885 return (GT1)super.removeRepetition("GT1", rep); 886 } 887 888 889 890 891 /** 892 * <p> 893 * Returns 894 * the first repetition of 895 * INSURANCE (a Group object) - creates it if necessary 896 * </p> 897 * 898 * 899 */ 900 public DFT_P11_INSURANCE getINSURANCE() { 901 return getTyped("INSURANCE", DFT_P11_INSURANCE.class); 902 } 903 904 905 /** 906 * <p> 907 * Returns a specific repetition of 908 * INSURANCE (a Group object) - creates it if necessary 909 * </p> 910 * 911 * 912 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 913 * @throws HL7Exception if the repetition requested is more than one 914 * greater than the number of existing repetitions. 915 */ 916 public DFT_P11_INSURANCE getINSURANCE(int rep) { 917 return getTyped("INSURANCE", rep, DFT_P11_INSURANCE.class); 918 } 919 920 /** 921 * <p> 922 * Returns the number of existing repetitions of INSURANCE 923 * </p> 924 * 925 */ 926 public int getINSURANCEReps() { 927 return getReps("INSURANCE"); 928 } 929 930 /** 931 * <p> 932 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 933 * <p> 934 * <p> 935 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 936 * if none are already present, so an empty list may be returned. 937 * </p> 938 * 939 */ 940 public java.util.List<DFT_P11_INSURANCE> getINSURANCEAll() throws HL7Exception { 941 return getAllAsList("INSURANCE", DFT_P11_INSURANCE.class); 942 } 943 944 /** 945 * <p> 946 * Inserts a specific repetition of INSURANCE (a Group object) 947 * </p> 948 * 949 * 950 * @see AbstractGroup#insertRepetition(Structure, int) 951 */ 952 public void insertINSURANCE(DFT_P11_INSURANCE structure, int rep) throws HL7Exception { 953 super.insertRepetition( "INSURANCE", structure, rep); 954 } 955 956 957 /** 958 * <p> 959 * Inserts a specific repetition of INSURANCE (a Group object) 960 * </p> 961 * 962 * 963 * @see AbstractGroup#insertRepetition(Structure, int) 964 */ 965 public DFT_P11_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 966 return (DFT_P11_INSURANCE)super.insertRepetition("INSURANCE", rep); 967 } 968 969 970 /** 971 * <p> 972 * Removes a specific repetition of INSURANCE (a Group object) 973 * </p> 974 * 975 * 976 * @see AbstractGroup#removeRepetition(String, int) 977 */ 978 public DFT_P11_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 979 return (DFT_P11_INSURANCE)super.removeRepetition("INSURANCE", rep); 980 } 981 982 983 984 985 /** 986 * <p> 987 * Returns 988 * ACC (Accident) - creates it if necessary 989 * </p> 990 * 991 * 992 */ 993 public ACC getACC() { 994 return getTyped("ACC", ACC.class); 995 } 996 997 998 999 1000 1001 /** 1002 * <p> 1003 * Returns 1004 * the first repetition of 1005 * FINANCIAL (a Group object) - creates it if necessary 1006 * </p> 1007 * 1008 * 1009 */ 1010 public DFT_P11_FINANCIAL getFINANCIAL() { 1011 return getTyped("FINANCIAL", DFT_P11_FINANCIAL.class); 1012 } 1013 1014 1015 /** 1016 * <p> 1017 * Returns a specific repetition of 1018 * FINANCIAL (a Group object) - creates it if necessary 1019 * </p> 1020 * 1021 * 1022 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1023 * @throws HL7Exception if the repetition requested is more than one 1024 * greater than the number of existing repetitions. 1025 */ 1026 public DFT_P11_FINANCIAL getFINANCIAL(int rep) { 1027 return getTyped("FINANCIAL", rep, DFT_P11_FINANCIAL.class); 1028 } 1029 1030 /** 1031 * <p> 1032 * Returns the number of existing repetitions of FINANCIAL 1033 * </p> 1034 * 1035 */ 1036 public int getFINANCIALReps() { 1037 return getReps("FINANCIAL"); 1038 } 1039 1040 /** 1041 * <p> 1042 * Returns a non-modifiable List containing all current existing repetitions of FINANCIAL. 1043 * <p> 1044 * <p> 1045 * Note that unlike {@link #getFINANCIAL()}, this method will not create any reps 1046 * if none are already present, so an empty list may be returned. 1047 * </p> 1048 * 1049 */ 1050 public java.util.List<DFT_P11_FINANCIAL> getFINANCIALAll() throws HL7Exception { 1051 return getAllAsList("FINANCIAL", DFT_P11_FINANCIAL.class); 1052 } 1053 1054 /** 1055 * <p> 1056 * Inserts a specific repetition of FINANCIAL (a Group object) 1057 * </p> 1058 * 1059 * 1060 * @see AbstractGroup#insertRepetition(Structure, int) 1061 */ 1062 public void insertFINANCIAL(DFT_P11_FINANCIAL structure, int rep) throws HL7Exception { 1063 super.insertRepetition( "FINANCIAL", structure, rep); 1064 } 1065 1066 1067 /** 1068 * <p> 1069 * Inserts a specific repetition of FINANCIAL (a Group object) 1070 * </p> 1071 * 1072 * 1073 * @see AbstractGroup#insertRepetition(Structure, int) 1074 */ 1075 public DFT_P11_FINANCIAL insertFINANCIAL(int rep) throws HL7Exception { 1076 return (DFT_P11_FINANCIAL)super.insertRepetition("FINANCIAL", rep); 1077 } 1078 1079 1080 /** 1081 * <p> 1082 * Removes a specific repetition of FINANCIAL (a Group object) 1083 * </p> 1084 * 1085 * 1086 * @see AbstractGroup#removeRepetition(String, int) 1087 */ 1088 public DFT_P11_FINANCIAL removeFINANCIAL(int rep) throws HL7Exception { 1089 return (DFT_P11_FINANCIAL)super.removeRepetition("FINANCIAL", rep); 1090 } 1091 1092 1093 1094} 1095