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