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