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