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