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