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