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