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