001/* 002 * This class is an auto-generated source file for a HAPI 003 * HL7 v2.x standard structure class. 004 * 005 * For more information, visit: http://hl7api.sourceforge.net/ 006 * 007 * The contents of this file are subject to the Mozilla Public License Version 1.1 008 * (the "License"); you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 010 * Software distributed under the License is distributed on an "AS IS" basis, 011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 012 * specific language governing rights and limitations under the License. 013 * 014 * The Original Code is "[file_name]". Description: 015 * "[one_line_description]" 016 * 017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 018 * 2012. All Rights Reserved. 019 * 020 * Contributor(s): ______________________________________. 021 * 022 * Alternatively, the contents of this file may be used under the terms of the 023 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 024 * applicable instead of those above. If you wish to allow use of your version of this 025 * file only under the terms of the GPL and not to allow others to use your version 026 * of this file under the MPL, indicate your decision by deleting the provisions above 027 * and replace them with the notice and other provisions required by the GPL License. 028 * If you do not delete the provisions above, a recipient may use your version of 029 * this file under either the MPL or the GPL. 030 * 031 */ 032 033 034package ca.uhn.hl7v2.model.v28.message; 035 036import ca.uhn.hl7v2.model.v28.group.*; 037import ca.uhn.hl7v2.model.v28.segment.*; 038 039import ca.uhn.hl7v2.HL7Exception; 040import ca.uhn.hl7v2.parser.ModelClassFactory; 041import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 042import ca.uhn.hl7v2.model.*; 043 044 045/** 046 * <p>Represents a RQA_I08 message structure (see chapter 11.4.1). This structure contains the 047 * following elements: </p> 048 * <ul> 049 * <li>1: MSH (Message Header) <b> </b> </li> 050 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li> 051 * <li>3: UAC (User Authentication Credential Segment) <b>optional </b> </li> 052 * <li>4: RF1 (Referral Information) <b>optional </b> </li> 053 * <li>5: RQA_I08_AUTHORIZATION (a Group object) <b>optional </b> </li> 054 * <li>6: RQA_I08_PROVIDER (a Group object) <b> repeating</b> </li> 055 * <li>7: PID (Patient Identification) <b> </b> </li> 056 * <li>8: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li> 057 * <li>9: RQA_I08_GUARANTOR_INSURANCE (a Group object) <b>optional </b> </li> 058 * <li>10: ACC (Accident) <b>optional </b> </li> 059 * <li>11: DG1 (Diagnosis) <b>optional repeating</b> </li> 060 * <li>12: DRG (Diagnosis Related Group) <b>optional repeating</b> </li> 061 * <li>13: AL1 (Patient Allergy Information) <b>optional repeating</b> </li> 062 * <li>14: RQA_I08_PROCEDURE (a Group object) <b>optional repeating</b> </li> 063 * <li>15: RQA_I08_OBSERVATION (a Group object) <b>optional repeating</b> </li> 064 * <li>16: RQA_I08_VISIT (a Group object) <b>optional </b> </li> 065 * <li>17: NTE (Notes and Comments) <b>optional repeating</b> </li> 066 * </ul> 067 */ 068//@SuppressWarnings("unused") 069public class RQA_I08 extends AbstractMessage { 070 071 /** 072 * Creates a new RQA_I08 message with DefaultModelClassFactory. 073 */ 074 public RQA_I08() { 075 this(new DefaultModelClassFactory()); 076 } 077 078 /** 079 * Creates a new RQA_I08 message with custom ModelClassFactory. 080 */ 081 public RQA_I08(ModelClassFactory factory) { 082 super(factory); 083 init(factory); 084 } 085 086 private void init(ModelClassFactory factory) { 087 try { 088 this.add(MSH.class, true, false); 089 this.add(SFT.class, false, true); 090 this.add(UAC.class, false, false); 091 this.add(RF1.class, false, false); 092 this.add(RQA_I08_AUTHORIZATION.class, false, false); 093 this.add(RQA_I08_PROVIDER.class, true, true); 094 this.add(PID.class, true, false); 095 this.add(NK1.class, false, true); 096 this.add(RQA_I08_GUARANTOR_INSURANCE.class, false, false); 097 this.add(ACC.class, false, false); 098 this.add(DG1.class, false, true); 099 this.add(DRG.class, false, true); 100 this.add(AL1.class, false, true); 101 this.add(RQA_I08_PROCEDURE.class, false, true); 102 this.add(RQA_I08_OBSERVATION.class, false, true); 103 this.add(RQA_I08_VISIT.class, false, false); 104 this.add(NTE.class, false, true); 105 } catch(HL7Exception e) { 106 log.error("Unexpected error creating RQA_I08 - this is probably a bug in the source code generator.", e); 107 } 108 } 109 110 111 /** 112 * Returns "2.8" 113 */ 114 public String getVersion() { 115 return "2.8"; 116 } 117 118 119 120 121 /** 122 * <p> 123 * Returns 124 * MSH (Message Header) - creates it if necessary 125 * </p> 126 * 127 * 128 */ 129 public MSH getMSH() { 130 return getTyped("MSH", MSH.class); 131 } 132 133 134 135 136 137 /** 138 * <p> 139 * Returns 140 * the first repetition of 141 * SFT (Software Segment) - creates it if necessary 142 * </p> 143 * 144 * 145 */ 146 public SFT getSFT() { 147 return getTyped("SFT", SFT.class); 148 } 149 150 151 /** 152 * <p> 153 * Returns a specific repetition of 154 * SFT (Software Segment) - creates it if necessary 155 * </p> 156 * 157 * 158 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 159 * @throws HL7Exception if the repetition requested is more than one 160 * greater than the number of existing repetitions. 161 */ 162 public SFT getSFT(int rep) { 163 return getTyped("SFT", rep, SFT.class); 164 } 165 166 /** 167 * <p> 168 * Returns the number of existing repetitions of SFT 169 * </p> 170 * 171 */ 172 public int getSFTReps() { 173 return getReps("SFT"); 174 } 175 176 /** 177 * <p> 178 * Returns a non-modifiable List containing all current existing repetitions of SFT. 179 * <p> 180 * <p> 181 * Note that unlike {@link #getSFT()}, this method will not create any reps 182 * if none are already present, so an empty list may be returned. 183 * </p> 184 * 185 */ 186 public java.util.List<SFT> getSFTAll() throws HL7Exception { 187 return getAllAsList("SFT", SFT.class); 188 } 189 190 /** 191 * <p> 192 * Inserts a specific repetition of SFT (Software Segment) 193 * </p> 194 * 195 * 196 * @see AbstractGroup#insertRepetition(Structure, int) 197 */ 198 public void insertSFT(SFT structure, int rep) throws HL7Exception { 199 super.insertRepetition( "SFT", structure, rep); 200 } 201 202 203 /** 204 * <p> 205 * Inserts a specific repetition of SFT (Software Segment) 206 * </p> 207 * 208 * 209 * @see AbstractGroup#insertRepetition(Structure, int) 210 */ 211 public SFT insertSFT(int rep) throws HL7Exception { 212 return (SFT)super.insertRepetition("SFT", rep); 213 } 214 215 216 /** 217 * <p> 218 * Removes a specific repetition of SFT (Software Segment) 219 * </p> 220 * 221 * 222 * @see AbstractGroup#removeRepetition(String, int) 223 */ 224 public SFT removeSFT(int rep) throws HL7Exception { 225 return (SFT)super.removeRepetition("SFT", rep); 226 } 227 228 229 230 231 /** 232 * <p> 233 * Returns 234 * UAC (User Authentication Credential Segment) - creates it if necessary 235 * </p> 236 * 237 * 238 */ 239 public UAC getUAC() { 240 return getTyped("UAC", UAC.class); 241 } 242 243 244 245 246 247 /** 248 * <p> 249 * Returns 250 * RF1 (Referral Information) - creates it if necessary 251 * </p> 252 * 253 * 254 */ 255 public RF1 getRF1() { 256 return getTyped("RF1", RF1.class); 257 } 258 259 260 261 262 263 /** 264 * <p> 265 * Returns 266 * AUTHORIZATION (a Group object) - creates it if necessary 267 * </p> 268 * 269 * 270 */ 271 public RQA_I08_AUTHORIZATION getAUTHORIZATION() { 272 return getTyped("AUTHORIZATION", RQA_I08_AUTHORIZATION.class); 273 } 274 275 276 277 278 279 /** 280 * <p> 281 * Returns 282 * the first repetition of 283 * PROVIDER (a Group object) - creates it if necessary 284 * </p> 285 * 286 * 287 */ 288 public RQA_I08_PROVIDER getPROVIDER() { 289 return getTyped("PROVIDER", RQA_I08_PROVIDER.class); 290 } 291 292 293 /** 294 * <p> 295 * Returns a specific repetition of 296 * PROVIDER (a Group object) - creates it if necessary 297 * </p> 298 * 299 * 300 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 301 * @throws HL7Exception if the repetition requested is more than one 302 * greater than the number of existing repetitions. 303 */ 304 public RQA_I08_PROVIDER getPROVIDER(int rep) { 305 return getTyped("PROVIDER", rep, RQA_I08_PROVIDER.class); 306 } 307 308 /** 309 * <p> 310 * Returns the number of existing repetitions of PROVIDER 311 * </p> 312 * 313 */ 314 public int getPROVIDERReps() { 315 return getReps("PROVIDER"); 316 } 317 318 /** 319 * <p> 320 * Returns a non-modifiable List containing all current existing repetitions of PROVIDER. 321 * <p> 322 * <p> 323 * Note that unlike {@link #getPROVIDER()}, this method will not create any reps 324 * if none are already present, so an empty list may be returned. 325 * </p> 326 * 327 */ 328 public java.util.List<RQA_I08_PROVIDER> getPROVIDERAll() throws HL7Exception { 329 return getAllAsList("PROVIDER", RQA_I08_PROVIDER.class); 330 } 331 332 /** 333 * <p> 334 * Inserts a specific repetition of PROVIDER (a Group object) 335 * </p> 336 * 337 * 338 * @see AbstractGroup#insertRepetition(Structure, int) 339 */ 340 public void insertPROVIDER(RQA_I08_PROVIDER structure, int rep) throws HL7Exception { 341 super.insertRepetition( "PROVIDER", structure, rep); 342 } 343 344 345 /** 346 * <p> 347 * Inserts a specific repetition of PROVIDER (a Group object) 348 * </p> 349 * 350 * 351 * @see AbstractGroup#insertRepetition(Structure, int) 352 */ 353 public RQA_I08_PROVIDER insertPROVIDER(int rep) throws HL7Exception { 354 return (RQA_I08_PROVIDER)super.insertRepetition("PROVIDER", rep); 355 } 356 357 358 /** 359 * <p> 360 * Removes a specific repetition of PROVIDER (a Group object) 361 * </p> 362 * 363 * 364 * @see AbstractGroup#removeRepetition(String, int) 365 */ 366 public RQA_I08_PROVIDER removePROVIDER(int rep) throws HL7Exception { 367 return (RQA_I08_PROVIDER)super.removeRepetition("PROVIDER", rep); 368 } 369 370 371 372 373 /** 374 * <p> 375 * Returns 376 * PID (Patient Identification) - creates it if necessary 377 * </p> 378 * 379 * 380 */ 381 public PID getPID() { 382 return getTyped("PID", PID.class); 383 } 384 385 386 387 388 389 /** 390 * <p> 391 * Returns 392 * the first repetition of 393 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 394 * </p> 395 * 396 * 397 */ 398 public NK1 getNK1() { 399 return getTyped("NK1", NK1.class); 400 } 401 402 403 /** 404 * <p> 405 * Returns a specific repetition of 406 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 407 * </p> 408 * 409 * 410 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 411 * @throws HL7Exception if the repetition requested is more than one 412 * greater than the number of existing repetitions. 413 */ 414 public NK1 getNK1(int rep) { 415 return getTyped("NK1", rep, NK1.class); 416 } 417 418 /** 419 * <p> 420 * Returns the number of existing repetitions of NK1 421 * </p> 422 * 423 */ 424 public int getNK1Reps() { 425 return getReps("NK1"); 426 } 427 428 /** 429 * <p> 430 * Returns a non-modifiable List containing all current existing repetitions of NK1. 431 * <p> 432 * <p> 433 * Note that unlike {@link #getNK1()}, this method will not create any reps 434 * if none are already present, so an empty list may be returned. 435 * </p> 436 * 437 */ 438 public java.util.List<NK1> getNK1All() throws HL7Exception { 439 return getAllAsList("NK1", NK1.class); 440 } 441 442 /** 443 * <p> 444 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 445 * </p> 446 * 447 * 448 * @see AbstractGroup#insertRepetition(Structure, int) 449 */ 450 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 451 super.insertRepetition( "NK1", structure, rep); 452 } 453 454 455 /** 456 * <p> 457 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 458 * </p> 459 * 460 * 461 * @see AbstractGroup#insertRepetition(Structure, int) 462 */ 463 public NK1 insertNK1(int rep) throws HL7Exception { 464 return (NK1)super.insertRepetition("NK1", rep); 465 } 466 467 468 /** 469 * <p> 470 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties) 471 * </p> 472 * 473 * 474 * @see AbstractGroup#removeRepetition(String, int) 475 */ 476 public NK1 removeNK1(int rep) throws HL7Exception { 477 return (NK1)super.removeRepetition("NK1", rep); 478 } 479 480 481 482 483 /** 484 * <p> 485 * Returns 486 * GUARANTOR_INSURANCE (a Group object) - creates it if necessary 487 * </p> 488 * 489 * 490 */ 491 public RQA_I08_GUARANTOR_INSURANCE getGUARANTOR_INSURANCE() { 492 return getTyped("GUARANTOR_INSURANCE", RQA_I08_GUARANTOR_INSURANCE.class); 493 } 494 495 496 497 498 499 /** 500 * <p> 501 * Returns 502 * ACC (Accident) - creates it if necessary 503 * </p> 504 * 505 * 506 */ 507 public ACC getACC() { 508 return getTyped("ACC", ACC.class); 509 } 510 511 512 513 514 515 /** 516 * <p> 517 * Returns 518 * the first repetition of 519 * DG1 (Diagnosis) - creates it if necessary 520 * </p> 521 * 522 * 523 */ 524 public DG1 getDG1() { 525 return getTyped("DG1", DG1.class); 526 } 527 528 529 /** 530 * <p> 531 * Returns a specific repetition of 532 * DG1 (Diagnosis) - creates it if necessary 533 * </p> 534 * 535 * 536 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 537 * @throws HL7Exception if the repetition requested is more than one 538 * greater than the number of existing repetitions. 539 */ 540 public DG1 getDG1(int rep) { 541 return getTyped("DG1", rep, DG1.class); 542 } 543 544 /** 545 * <p> 546 * Returns the number of existing repetitions of DG1 547 * </p> 548 * 549 */ 550 public int getDG1Reps() { 551 return getReps("DG1"); 552 } 553 554 /** 555 * <p> 556 * Returns a non-modifiable List containing all current existing repetitions of DG1. 557 * <p> 558 * <p> 559 * Note that unlike {@link #getDG1()}, this method will not create any reps 560 * if none are already present, so an empty list may be returned. 561 * </p> 562 * 563 */ 564 public java.util.List<DG1> getDG1All() throws HL7Exception { 565 return getAllAsList("DG1", DG1.class); 566 } 567 568 /** 569 * <p> 570 * Inserts a specific repetition of DG1 (Diagnosis) 571 * </p> 572 * 573 * 574 * @see AbstractGroup#insertRepetition(Structure, int) 575 */ 576 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 577 super.insertRepetition( "DG1", structure, rep); 578 } 579 580 581 /** 582 * <p> 583 * Inserts a specific repetition of DG1 (Diagnosis) 584 * </p> 585 * 586 * 587 * @see AbstractGroup#insertRepetition(Structure, int) 588 */ 589 public DG1 insertDG1(int rep) throws HL7Exception { 590 return (DG1)super.insertRepetition("DG1", rep); 591 } 592 593 594 /** 595 * <p> 596 * Removes a specific repetition of DG1 (Diagnosis) 597 * </p> 598 * 599 * 600 * @see AbstractGroup#removeRepetition(String, int) 601 */ 602 public DG1 removeDG1(int rep) throws HL7Exception { 603 return (DG1)super.removeRepetition("DG1", rep); 604 } 605 606 607 608 609 /** 610 * <p> 611 * Returns 612 * the first repetition of 613 * DRG (Diagnosis Related Group) - creates it if necessary 614 * </p> 615 * 616 * 617 */ 618 public DRG getDRG() { 619 return getTyped("DRG", DRG.class); 620 } 621 622 623 /** 624 * <p> 625 * Returns a specific repetition of 626 * DRG (Diagnosis Related Group) - creates it if necessary 627 * </p> 628 * 629 * 630 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 631 * @throws HL7Exception if the repetition requested is more than one 632 * greater than the number of existing repetitions. 633 */ 634 public DRG getDRG(int rep) { 635 return getTyped("DRG", rep, DRG.class); 636 } 637 638 /** 639 * <p> 640 * Returns the number of existing repetitions of DRG 641 * </p> 642 * 643 */ 644 public int getDRGReps() { 645 return getReps("DRG"); 646 } 647 648 /** 649 * <p> 650 * Returns a non-modifiable List containing all current existing repetitions of DRG. 651 * <p> 652 * <p> 653 * Note that unlike {@link #getDRG()}, this method will not create any reps 654 * if none are already present, so an empty list may be returned. 655 * </p> 656 * 657 */ 658 public java.util.List<DRG> getDRGAll() throws HL7Exception { 659 return getAllAsList("DRG", DRG.class); 660 } 661 662 /** 663 * <p> 664 * Inserts a specific repetition of DRG (Diagnosis Related Group) 665 * </p> 666 * 667 * 668 * @see AbstractGroup#insertRepetition(Structure, int) 669 */ 670 public void insertDRG(DRG structure, int rep) throws HL7Exception { 671 super.insertRepetition( "DRG", structure, rep); 672 } 673 674 675 /** 676 * <p> 677 * Inserts a specific repetition of DRG (Diagnosis Related Group) 678 * </p> 679 * 680 * 681 * @see AbstractGroup#insertRepetition(Structure, int) 682 */ 683 public DRG insertDRG(int rep) throws HL7Exception { 684 return (DRG)super.insertRepetition("DRG", rep); 685 } 686 687 688 /** 689 * <p> 690 * Removes a specific repetition of DRG (Diagnosis Related Group) 691 * </p> 692 * 693 * 694 * @see AbstractGroup#removeRepetition(String, int) 695 */ 696 public DRG removeDRG(int rep) throws HL7Exception { 697 return (DRG)super.removeRepetition("DRG", rep); 698 } 699 700 701 702 703 /** 704 * <p> 705 * Returns 706 * the first repetition of 707 * AL1 (Patient Allergy Information) - creates it if necessary 708 * </p> 709 * 710 * 711 */ 712 public AL1 getAL1() { 713 return getTyped("AL1", AL1.class); 714 } 715 716 717 /** 718 * <p> 719 * Returns a specific repetition of 720 * AL1 (Patient Allergy Information) - creates it if necessary 721 * </p> 722 * 723 * 724 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 725 * @throws HL7Exception if the repetition requested is more than one 726 * greater than the number of existing repetitions. 727 */ 728 public AL1 getAL1(int rep) { 729 return getTyped("AL1", rep, AL1.class); 730 } 731 732 /** 733 * <p> 734 * Returns the number of existing repetitions of AL1 735 * </p> 736 * 737 */ 738 public int getAL1Reps() { 739 return getReps("AL1"); 740 } 741 742 /** 743 * <p> 744 * Returns a non-modifiable List containing all current existing repetitions of AL1. 745 * <p> 746 * <p> 747 * Note that unlike {@link #getAL1()}, this method will not create any reps 748 * if none are already present, so an empty list may be returned. 749 * </p> 750 * 751 */ 752 public java.util.List<AL1> getAL1All() throws HL7Exception { 753 return getAllAsList("AL1", AL1.class); 754 } 755 756 /** 757 * <p> 758 * Inserts a specific repetition of AL1 (Patient Allergy Information) 759 * </p> 760 * 761 * 762 * @see AbstractGroup#insertRepetition(Structure, int) 763 */ 764 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 765 super.insertRepetition( "AL1", structure, rep); 766 } 767 768 769 /** 770 * <p> 771 * Inserts a specific repetition of AL1 (Patient Allergy Information) 772 * </p> 773 * 774 * 775 * @see AbstractGroup#insertRepetition(Structure, int) 776 */ 777 public AL1 insertAL1(int rep) throws HL7Exception { 778 return (AL1)super.insertRepetition("AL1", rep); 779 } 780 781 782 /** 783 * <p> 784 * Removes a specific repetition of AL1 (Patient Allergy Information) 785 * </p> 786 * 787 * 788 * @see AbstractGroup#removeRepetition(String, int) 789 */ 790 public AL1 removeAL1(int rep) throws HL7Exception { 791 return (AL1)super.removeRepetition("AL1", rep); 792 } 793 794 795 796 797 /** 798 * <p> 799 * Returns 800 * the first repetition of 801 * PROCEDURE (a Group object) - creates it if necessary 802 * </p> 803 * 804 * 805 */ 806 public RQA_I08_PROCEDURE getPROCEDURE() { 807 return getTyped("PROCEDURE", RQA_I08_PROCEDURE.class); 808 } 809 810 811 /** 812 * <p> 813 * Returns a specific repetition of 814 * PROCEDURE (a Group object) - creates it if necessary 815 * </p> 816 * 817 * 818 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 819 * @throws HL7Exception if the repetition requested is more than one 820 * greater than the number of existing repetitions. 821 */ 822 public RQA_I08_PROCEDURE getPROCEDURE(int rep) { 823 return getTyped("PROCEDURE", rep, RQA_I08_PROCEDURE.class); 824 } 825 826 /** 827 * <p> 828 * Returns the number of existing repetitions of PROCEDURE 829 * </p> 830 * 831 */ 832 public int getPROCEDUREReps() { 833 return getReps("PROCEDURE"); 834 } 835 836 /** 837 * <p> 838 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 839 * <p> 840 * <p> 841 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 842 * if none are already present, so an empty list may be returned. 843 * </p> 844 * 845 */ 846 public java.util.List<RQA_I08_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 847 return getAllAsList("PROCEDURE", RQA_I08_PROCEDURE.class); 848 } 849 850 /** 851 * <p> 852 * Inserts a specific repetition of PROCEDURE (a Group object) 853 * </p> 854 * 855 * 856 * @see AbstractGroup#insertRepetition(Structure, int) 857 */ 858 public void insertPROCEDURE(RQA_I08_PROCEDURE structure, int rep) throws HL7Exception { 859 super.insertRepetition( "PROCEDURE", structure, rep); 860 } 861 862 863 /** 864 * <p> 865 * Inserts a specific repetition of PROCEDURE (a Group object) 866 * </p> 867 * 868 * 869 * @see AbstractGroup#insertRepetition(Structure, int) 870 */ 871 public RQA_I08_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 872 return (RQA_I08_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 873 } 874 875 876 /** 877 * <p> 878 * Removes a specific repetition of PROCEDURE (a Group object) 879 * </p> 880 * 881 * 882 * @see AbstractGroup#removeRepetition(String, int) 883 */ 884 public RQA_I08_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 885 return (RQA_I08_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 886 } 887 888 889 890 891 /** 892 * <p> 893 * Returns 894 * the first repetition of 895 * OBSERVATION (a Group object) - creates it if necessary 896 * </p> 897 * 898 * 899 */ 900 public RQA_I08_OBSERVATION getOBSERVATION() { 901 return getTyped("OBSERVATION", RQA_I08_OBSERVATION.class); 902 } 903 904 905 /** 906 * <p> 907 * Returns a specific repetition of 908 * OBSERVATION (a Group object) - creates it if necessary 909 * </p> 910 * 911 * 912 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 913 * @throws HL7Exception if the repetition requested is more than one 914 * greater than the number of existing repetitions. 915 */ 916 public RQA_I08_OBSERVATION getOBSERVATION(int rep) { 917 return getTyped("OBSERVATION", rep, RQA_I08_OBSERVATION.class); 918 } 919 920 /** 921 * <p> 922 * Returns the number of existing repetitions of OBSERVATION 923 * </p> 924 * 925 */ 926 public int getOBSERVATIONReps() { 927 return getReps("OBSERVATION"); 928 } 929 930 /** 931 * <p> 932 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION. 933 * <p> 934 * <p> 935 * Note that unlike {@link #getOBSERVATION()}, this method will not create any reps 936 * if none are already present, so an empty list may be returned. 937 * </p> 938 * 939 */ 940 public java.util.List<RQA_I08_OBSERVATION> getOBSERVATIONAll() throws HL7Exception { 941 return getAllAsList("OBSERVATION", RQA_I08_OBSERVATION.class); 942 } 943 944 /** 945 * <p> 946 * Inserts a specific repetition of OBSERVATION (a Group object) 947 * </p> 948 * 949 * 950 * @see AbstractGroup#insertRepetition(Structure, int) 951 */ 952 public void insertOBSERVATION(RQA_I08_OBSERVATION structure, int rep) throws HL7Exception { 953 super.insertRepetition( "OBSERVATION", structure, rep); 954 } 955 956 957 /** 958 * <p> 959 * Inserts a specific repetition of OBSERVATION (a Group object) 960 * </p> 961 * 962 * 963 * @see AbstractGroup#insertRepetition(Structure, int) 964 */ 965 public RQA_I08_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception { 966 return (RQA_I08_OBSERVATION)super.insertRepetition("OBSERVATION", rep); 967 } 968 969 970 /** 971 * <p> 972 * Removes a specific repetition of OBSERVATION (a Group object) 973 * </p> 974 * 975 * 976 * @see AbstractGroup#removeRepetition(String, int) 977 */ 978 public RQA_I08_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception { 979 return (RQA_I08_OBSERVATION)super.removeRepetition("OBSERVATION", rep); 980 } 981 982 983 984 985 /** 986 * <p> 987 * Returns 988 * VISIT (a Group object) - creates it if necessary 989 * </p> 990 * 991 * 992 */ 993 public RQA_I08_VISIT getVISIT() { 994 return getTyped("VISIT", RQA_I08_VISIT.class); 995 } 996 997 998 999 1000 1001 /** 1002 * <p> 1003 * Returns 1004 * the first repetition of 1005 * NTE (Notes and Comments) - creates it if necessary 1006 * </p> 1007 * 1008 * 1009 */ 1010 public NTE getNTE() { 1011 return getTyped("NTE", NTE.class); 1012 } 1013 1014 1015 /** 1016 * <p> 1017 * Returns a specific repetition of 1018 * NTE (Notes and Comments) - creates it if necessary 1019 * </p> 1020 * 1021 * 1022 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1023 * @throws HL7Exception if the repetition requested is more than one 1024 * greater than the number of existing repetitions. 1025 */ 1026 public NTE getNTE(int rep) { 1027 return getTyped("NTE", rep, NTE.class); 1028 } 1029 1030 /** 1031 * <p> 1032 * Returns the number of existing repetitions of NTE 1033 * </p> 1034 * 1035 */ 1036 public int getNTEReps() { 1037 return getReps("NTE"); 1038 } 1039 1040 /** 1041 * <p> 1042 * Returns a non-modifiable List containing all current existing repetitions of NTE. 1043 * <p> 1044 * <p> 1045 * Note that unlike {@link #getNTE()}, this method will not create any reps 1046 * if none are already present, so an empty list may be returned. 1047 * </p> 1048 * 1049 */ 1050 public java.util.List<NTE> getNTEAll() throws HL7Exception { 1051 return getAllAsList("NTE", NTE.class); 1052 } 1053 1054 /** 1055 * <p> 1056 * Inserts a specific repetition of NTE (Notes and Comments) 1057 * </p> 1058 * 1059 * 1060 * @see AbstractGroup#insertRepetition(Structure, int) 1061 */ 1062 public void insertNTE(NTE structure, int rep) throws HL7Exception { 1063 super.insertRepetition( "NTE", structure, rep); 1064 } 1065 1066 1067 /** 1068 * <p> 1069 * Inserts a specific repetition of NTE (Notes and Comments) 1070 * </p> 1071 * 1072 * 1073 * @see AbstractGroup#insertRepetition(Structure, int) 1074 */ 1075 public NTE insertNTE(int rep) throws HL7Exception { 1076 return (NTE)super.insertRepetition("NTE", rep); 1077 } 1078 1079 1080 /** 1081 * <p> 1082 * Removes a specific repetition of NTE (Notes and Comments) 1083 * </p> 1084 * 1085 * 1086 * @see AbstractGroup#removeRepetition(String, int) 1087 */ 1088 public NTE removeNTE(int rep) throws HL7Exception { 1089 return (NTE)super.removeRepetition("NTE", rep); 1090 } 1091 1092 1093 1094} 1095