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.v27.message; 035 036import ca.uhn.hl7v2.model.v27.group.*; 037import ca.uhn.hl7v2.model.v27.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_A16 message structure (see chapter 3.3.16). This structure contains the 047 * following elements: </p> 048 * <ul> 049 * <li>1: MSH (Message Header) <b> </b> </li> 050 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li> 051 * <li>3: UAC (User Authentication Credential Segment) <b>optional </b> </li> 052 * <li>4: EVN (Event Type) <b> </b> </li> 053 * <li>5: PID (Patient Identification) <b> </b> </li> 054 * <li>6: PD1 (Patient Additional Demographic) <b>optional </b> </li> 055 * <li>7: ARV (Access Restriction) <b>optional repeating</b> </li> 056 * <li>8: ROL (Role) <b>optional repeating</b> </li> 057 * <li>9: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li> 058 * <li>10: PV1 (Patient Visit) <b> </b> </li> 059 * <li>11: PV2 (Patient Visit - Additional Information) <b>optional </b> </li> 060 * <li>12: ARV (Access Restriction) <b>optional repeating</b> </li> 061 * <li>13: ROL (Role) <b>optional repeating</b> </li> 062 * <li>14: DB1 (Disability) <b>optional repeating</b> </li> 063 * <li>15: OBX (Observation/Result) <b>optional repeating</b> </li> 064 * <li>16: AL1 (Patient Allergy Information) <b>optional repeating</b> </li> 065 * <li>17: DG1 (Diagnosis) <b>optional repeating</b> </li> 066 * <li>18: DRG (Diagnosis Related Group) <b>optional </b> </li> 067 * <li>19: ADT_A16_PROCEDURE (a Group object) <b>optional repeating</b> </li> 068 * <li>20: GT1 (Guarantor) <b>optional repeating</b> </li> 069 * <li>21: ADT_A16_INSURANCE (a Group object) <b>optional repeating</b> </li> 070 * <li>22: ACC (Accident) <b>optional </b> </li> 071 * </ul> 072 */ 073//@SuppressWarnings("unused") 074public class ADT_A16 extends AbstractMessage { 075 076 /** 077 * Creates a new ADT_A16 message with DefaultModelClassFactory. 078 */ 079 public ADT_A16() { 080 this(new DefaultModelClassFactory()); 081 } 082 083 /** 084 * Creates a new ADT_A16 message with custom ModelClassFactory. 085 */ 086 public ADT_A16(ModelClassFactory factory) { 087 super(factory); 088 init(factory); 089 } 090 091 private void init(ModelClassFactory factory) { 092 try { 093 this.add(MSH.class, true, false); 094 this.add(SFT.class, false, true); 095 this.add(UAC.class, false, false); 096 this.add(EVN.class, true, false); 097 this.add(PID.class, true, false); 098 this.add(PD1.class, false, false); 099 this.add(ARV.class, false, true); 100 this.add(ROL.class, false, true); 101 this.add(NK1.class, false, true); 102 this.add(PV1.class, true, false); 103 this.add(PV2.class, false, false); 104 this.add(ARV.class, false, true); 105 this.add(ROL.class, false, true); 106 this.add(DB1.class, false, true); 107 this.add(OBX.class, false, true); 108 this.add(AL1.class, false, true); 109 this.add(DG1.class, false, true); 110 this.add(DRG.class, false, false); 111 this.add(ADT_A16_PROCEDURE.class, false, true); 112 this.add(GT1.class, false, true); 113 this.add(ADT_A16_INSURANCE.class, false, true); 114 this.add(ACC.class, false, false); 115 } catch(HL7Exception e) { 116 log.error("Unexpected error creating ADT_A16 - this is probably a bug in the source code generator.", e); 117 } 118 } 119 120 121 /** 122 * Returns "2.7" 123 */ 124 public String getVersion() { 125 return "2.7"; 126 } 127 128 129 130 131 /** 132 * <p> 133 * Returns 134 * MSH (Message Header) - creates it if necessary 135 * </p> 136 * 137 * 138 */ 139 public MSH getMSH() { 140 return getTyped("MSH", MSH.class); 141 } 142 143 144 145 146 147 /** 148 * <p> 149 * Returns 150 * the first repetition of 151 * SFT (Software Segment) - creates it if necessary 152 * </p> 153 * 154 * 155 */ 156 public SFT getSFT() { 157 return getTyped("SFT", SFT.class); 158 } 159 160 161 /** 162 * <p> 163 * Returns a specific repetition of 164 * SFT (Software Segment) - creates it if necessary 165 * </p> 166 * 167 * 168 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 169 * @throws HL7Exception if the repetition requested is more than one 170 * greater than the number of existing repetitions. 171 */ 172 public SFT getSFT(int rep) { 173 return getTyped("SFT", rep, SFT.class); 174 } 175 176 /** 177 * <p> 178 * Returns the number of existing repetitions of SFT 179 * </p> 180 * 181 */ 182 public int getSFTReps() { 183 return getReps("SFT"); 184 } 185 186 /** 187 * <p> 188 * Returns a non-modifiable List containing all current existing repetitions of SFT. 189 * <p> 190 * <p> 191 * Note that unlike {@link #getSFT()}, this method will not create any reps 192 * if none are already present, so an empty list may be returned. 193 * </p> 194 * 195 */ 196 public java.util.List<SFT> getSFTAll() throws HL7Exception { 197 return getAllAsList("SFT", SFT.class); 198 } 199 200 /** 201 * <p> 202 * Inserts a specific repetition of SFT (Software Segment) 203 * </p> 204 * 205 * 206 * @see AbstractGroup#insertRepetition(Structure, int) 207 */ 208 public void insertSFT(SFT structure, int rep) throws HL7Exception { 209 super.insertRepetition( "SFT", structure, rep); 210 } 211 212 213 /** 214 * <p> 215 * Inserts a specific repetition of SFT (Software Segment) 216 * </p> 217 * 218 * 219 * @see AbstractGroup#insertRepetition(Structure, int) 220 */ 221 public SFT insertSFT(int rep) throws HL7Exception { 222 return (SFT)super.insertRepetition("SFT", rep); 223 } 224 225 226 /** 227 * <p> 228 * Removes a specific repetition of SFT (Software Segment) 229 * </p> 230 * 231 * 232 * @see AbstractGroup#removeRepetition(String, int) 233 */ 234 public SFT removeSFT(int rep) throws HL7Exception { 235 return (SFT)super.removeRepetition("SFT", rep); 236 } 237 238 239 240 241 /** 242 * <p> 243 * Returns 244 * UAC (User Authentication Credential Segment) - creates it if necessary 245 * </p> 246 * 247 * 248 */ 249 public UAC getUAC() { 250 return getTyped("UAC", UAC.class); 251 } 252 253 254 255 256 257 /** 258 * <p> 259 * Returns 260 * EVN (Event Type) - creates it if necessary 261 * </p> 262 * 263 * 264 */ 265 public EVN getEVN() { 266 return getTyped("EVN", EVN.class); 267 } 268 269 270 271 272 273 /** 274 * <p> 275 * Returns 276 * PID (Patient Identification) - creates it if necessary 277 * </p> 278 * 279 * 280 */ 281 public PID getPID() { 282 return getTyped("PID", PID.class); 283 } 284 285 286 287 288 289 /** 290 * <p> 291 * Returns 292 * PD1 (Patient Additional Demographic) - creates it if necessary 293 * </p> 294 * 295 * 296 */ 297 public PD1 getPD1() { 298 return getTyped("PD1", PD1.class); 299 } 300 301 302 303 304 305 /** 306 * <p> 307 * Returns 308 * the first repetition of 309 * ARV (Access Restriction) - creates it if necessary 310 * </p> 311 * 312 * 313 */ 314 public ARV getARV() { 315 return getTyped("ARV", ARV.class); 316 } 317 318 319 /** 320 * <p> 321 * Returns a specific repetition of 322 * ARV (Access Restriction) - creates it if necessary 323 * </p> 324 * 325 * 326 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 327 * @throws HL7Exception if the repetition requested is more than one 328 * greater than the number of existing repetitions. 329 */ 330 public ARV getARV(int rep) { 331 return getTyped("ARV", rep, ARV.class); 332 } 333 334 /** 335 * <p> 336 * Returns the number of existing repetitions of ARV 337 * </p> 338 * 339 */ 340 public int getARVReps() { 341 return getReps("ARV"); 342 } 343 344 /** 345 * <p> 346 * Returns a non-modifiable List containing all current existing repetitions of ARV. 347 * <p> 348 * <p> 349 * Note that unlike {@link #getARV()}, this method will not create any reps 350 * if none are already present, so an empty list may be returned. 351 * </p> 352 * 353 */ 354 public java.util.List<ARV> getARVAll() throws HL7Exception { 355 return getAllAsList("ARV", ARV.class); 356 } 357 358 /** 359 * <p> 360 * Inserts a specific repetition of ARV (Access Restriction) 361 * </p> 362 * 363 * 364 * @see AbstractGroup#insertRepetition(Structure, int) 365 */ 366 public void insertARV(ARV structure, int rep) throws HL7Exception { 367 super.insertRepetition( "ARV", structure, rep); 368 } 369 370 371 /** 372 * <p> 373 * Inserts a specific repetition of ARV (Access Restriction) 374 * </p> 375 * 376 * 377 * @see AbstractGroup#insertRepetition(Structure, int) 378 */ 379 public ARV insertARV(int rep) throws HL7Exception { 380 return (ARV)super.insertRepetition("ARV", rep); 381 } 382 383 384 /** 385 * <p> 386 * Removes a specific repetition of ARV (Access Restriction) 387 * </p> 388 * 389 * 390 * @see AbstractGroup#removeRepetition(String, int) 391 */ 392 public ARV removeARV(int rep) throws HL7Exception { 393 return (ARV)super.removeRepetition("ARV", rep); 394 } 395 396 397 398 399 /** 400 * <p> 401 * Returns 402 * the first repetition of 403 * ROL (Role) - creates it if necessary 404 * </p> 405 * 406 * 407 */ 408 public ROL getROL() { 409 return getTyped("ROL", ROL.class); 410 } 411 412 413 /** 414 * <p> 415 * Returns a specific repetition of 416 * ROL (Role) - creates it if necessary 417 * </p> 418 * 419 * 420 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 421 * @throws HL7Exception if the repetition requested is more than one 422 * greater than the number of existing repetitions. 423 */ 424 public ROL getROL(int rep) { 425 return getTyped("ROL", rep, ROL.class); 426 } 427 428 /** 429 * <p> 430 * Returns the number of existing repetitions of ROL 431 * </p> 432 * 433 */ 434 public int getROLReps() { 435 return getReps("ROL"); 436 } 437 438 /** 439 * <p> 440 * Returns a non-modifiable List containing all current existing repetitions of ROL. 441 * <p> 442 * <p> 443 * Note that unlike {@link #getROL()}, this method will not create any reps 444 * if none are already present, so an empty list may be returned. 445 * </p> 446 * 447 */ 448 public java.util.List<ROL> getROLAll() throws HL7Exception { 449 return getAllAsList("ROL", ROL.class); 450 } 451 452 /** 453 * <p> 454 * Inserts a specific repetition of ROL (Role) 455 * </p> 456 * 457 * 458 * @see AbstractGroup#insertRepetition(Structure, int) 459 */ 460 public void insertROL(ROL structure, int rep) throws HL7Exception { 461 super.insertRepetition( "ROL", structure, rep); 462 } 463 464 465 /** 466 * <p> 467 * Inserts a specific repetition of ROL (Role) 468 * </p> 469 * 470 * 471 * @see AbstractGroup#insertRepetition(Structure, int) 472 */ 473 public ROL insertROL(int rep) throws HL7Exception { 474 return (ROL)super.insertRepetition("ROL", rep); 475 } 476 477 478 /** 479 * <p> 480 * Removes a specific repetition of ROL (Role) 481 * </p> 482 * 483 * 484 * @see AbstractGroup#removeRepetition(String, int) 485 */ 486 public ROL removeROL(int rep) throws HL7Exception { 487 return (ROL)super.removeRepetition("ROL", rep); 488 } 489 490 491 492 493 /** 494 * <p> 495 * Returns 496 * the first repetition of 497 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 498 * </p> 499 * 500 * 501 */ 502 public NK1 getNK1() { 503 return getTyped("NK1", NK1.class); 504 } 505 506 507 /** 508 * <p> 509 * Returns a specific repetition of 510 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 511 * </p> 512 * 513 * 514 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 515 * @throws HL7Exception if the repetition requested is more than one 516 * greater than the number of existing repetitions. 517 */ 518 public NK1 getNK1(int rep) { 519 return getTyped("NK1", rep, NK1.class); 520 } 521 522 /** 523 * <p> 524 * Returns the number of existing repetitions of NK1 525 * </p> 526 * 527 */ 528 public int getNK1Reps() { 529 return getReps("NK1"); 530 } 531 532 /** 533 * <p> 534 * Returns a non-modifiable List containing all current existing repetitions of NK1. 535 * <p> 536 * <p> 537 * Note that unlike {@link #getNK1()}, this method will not create any reps 538 * if none are already present, so an empty list may be returned. 539 * </p> 540 * 541 */ 542 public java.util.List<NK1> getNK1All() throws HL7Exception { 543 return getAllAsList("NK1", NK1.class); 544 } 545 546 /** 547 * <p> 548 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 549 * </p> 550 * 551 * 552 * @see AbstractGroup#insertRepetition(Structure, int) 553 */ 554 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 555 super.insertRepetition( "NK1", structure, rep); 556 } 557 558 559 /** 560 * <p> 561 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 562 * </p> 563 * 564 * 565 * @see AbstractGroup#insertRepetition(Structure, int) 566 */ 567 public NK1 insertNK1(int rep) throws HL7Exception { 568 return (NK1)super.insertRepetition("NK1", rep); 569 } 570 571 572 /** 573 * <p> 574 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties) 575 * </p> 576 * 577 * 578 * @see AbstractGroup#removeRepetition(String, int) 579 */ 580 public NK1 removeNK1(int rep) throws HL7Exception { 581 return (NK1)super.removeRepetition("NK1", rep); 582 } 583 584 585 586 587 /** 588 * <p> 589 * Returns 590 * PV1 (Patient Visit) - creates it if necessary 591 * </p> 592 * 593 * 594 */ 595 public PV1 getPV1() { 596 return getTyped("PV1", PV1.class); 597 } 598 599 600 601 602 603 /** 604 * <p> 605 * Returns 606 * PV2 (Patient Visit - Additional Information) - creates it if necessary 607 * </p> 608 * 609 * 610 */ 611 public PV2 getPV2() { 612 return getTyped("PV2", PV2.class); 613 } 614 615 616 617 618 619 /** 620 * <p> 621 * Returns 622 * the first repetition of 623 * ARV2 (Access Restriction) - creates it if necessary 624 * </p> 625 * 626 * 627 */ 628 public ARV getARV2() { 629 return getTyped("ARV2", ARV.class); 630 } 631 632 633 /** 634 * <p> 635 * Returns a specific repetition of 636 * ARV2 (Access Restriction) - creates it if necessary 637 * </p> 638 * 639 * 640 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 641 * @throws HL7Exception if the repetition requested is more than one 642 * greater than the number of existing repetitions. 643 */ 644 public ARV getARV2(int rep) { 645 return getTyped("ARV2", rep, ARV.class); 646 } 647 648 /** 649 * <p> 650 * Returns the number of existing repetitions of ARV2 651 * </p> 652 * 653 */ 654 public int getARV2Reps() { 655 return getReps("ARV2"); 656 } 657 658 /** 659 * <p> 660 * Returns a non-modifiable List containing all current existing repetitions of ARV2. 661 * <p> 662 * <p> 663 * Note that unlike {@link #getARV2()}, this method will not create any reps 664 * if none are already present, so an empty list may be returned. 665 * </p> 666 * 667 */ 668 public java.util.List<ARV> getARV2All() throws HL7Exception { 669 return getAllAsList("ARV2", ARV.class); 670 } 671 672 /** 673 * <p> 674 * Inserts a specific repetition of ARV2 (Access Restriction) 675 * </p> 676 * 677 * 678 * @see AbstractGroup#insertRepetition(Structure, int) 679 */ 680 public void insertARV2(ARV structure, int rep) throws HL7Exception { 681 super.insertRepetition( "ARV2", structure, rep); 682 } 683 684 685 /** 686 * <p> 687 * Inserts a specific repetition of ARV2 (Access Restriction) 688 * </p> 689 * 690 * 691 * @see AbstractGroup#insertRepetition(Structure, int) 692 */ 693 public ARV insertARV2(int rep) throws HL7Exception { 694 return (ARV)super.insertRepetition("ARV2", rep); 695 } 696 697 698 /** 699 * <p> 700 * Removes a specific repetition of ARV2 (Access Restriction) 701 * </p> 702 * 703 * 704 * @see AbstractGroup#removeRepetition(String, int) 705 */ 706 public ARV removeARV2(int rep) throws HL7Exception { 707 return (ARV)super.removeRepetition("ARV2", rep); 708 } 709 710 711 712 713 /** 714 * <p> 715 * Returns 716 * the first repetition of 717 * ROL2 (Role) - creates it if necessary 718 * </p> 719 * 720 * 721 */ 722 public ROL getROL2() { 723 return getTyped("ROL2", ROL.class); 724 } 725 726 727 /** 728 * <p> 729 * Returns a specific repetition of 730 * ROL2 (Role) - creates it if necessary 731 * </p> 732 * 733 * 734 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 735 * @throws HL7Exception if the repetition requested is more than one 736 * greater than the number of existing repetitions. 737 */ 738 public ROL getROL2(int rep) { 739 return getTyped("ROL2", rep, ROL.class); 740 } 741 742 /** 743 * <p> 744 * Returns the number of existing repetitions of ROL2 745 * </p> 746 * 747 */ 748 public int getROL2Reps() { 749 return getReps("ROL2"); 750 } 751 752 /** 753 * <p> 754 * Returns a non-modifiable List containing all current existing repetitions of ROL2. 755 * <p> 756 * <p> 757 * Note that unlike {@link #getROL2()}, this method will not create any reps 758 * if none are already present, so an empty list may be returned. 759 * </p> 760 * 761 */ 762 public java.util.List<ROL> getROL2All() throws HL7Exception { 763 return getAllAsList("ROL2", ROL.class); 764 } 765 766 /** 767 * <p> 768 * Inserts a specific repetition of ROL2 (Role) 769 * </p> 770 * 771 * 772 * @see AbstractGroup#insertRepetition(Structure, int) 773 */ 774 public void insertROL2(ROL structure, int rep) throws HL7Exception { 775 super.insertRepetition( "ROL2", structure, rep); 776 } 777 778 779 /** 780 * <p> 781 * Inserts a specific repetition of ROL2 (Role) 782 * </p> 783 * 784 * 785 * @see AbstractGroup#insertRepetition(Structure, int) 786 */ 787 public ROL insertROL2(int rep) throws HL7Exception { 788 return (ROL)super.insertRepetition("ROL2", rep); 789 } 790 791 792 /** 793 * <p> 794 * Removes a specific repetition of ROL2 (Role) 795 * </p> 796 * 797 * 798 * @see AbstractGroup#removeRepetition(String, int) 799 */ 800 public ROL removeROL2(int rep) throws HL7Exception { 801 return (ROL)super.removeRepetition("ROL2", rep); 802 } 803 804 805 806 807 /** 808 * <p> 809 * Returns 810 * the first repetition of 811 * DB1 (Disability) - creates it if necessary 812 * </p> 813 * 814 * 815 */ 816 public DB1 getDB1() { 817 return getTyped("DB1", DB1.class); 818 } 819 820 821 /** 822 * <p> 823 * Returns a specific repetition of 824 * DB1 (Disability) - creates it if necessary 825 * </p> 826 * 827 * 828 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 829 * @throws HL7Exception if the repetition requested is more than one 830 * greater than the number of existing repetitions. 831 */ 832 public DB1 getDB1(int rep) { 833 return getTyped("DB1", rep, DB1.class); 834 } 835 836 /** 837 * <p> 838 * Returns the number of existing repetitions of DB1 839 * </p> 840 * 841 */ 842 public int getDB1Reps() { 843 return getReps("DB1"); 844 } 845 846 /** 847 * <p> 848 * Returns a non-modifiable List containing all current existing repetitions of DB1. 849 * <p> 850 * <p> 851 * Note that unlike {@link #getDB1()}, this method will not create any reps 852 * if none are already present, so an empty list may be returned. 853 * </p> 854 * 855 */ 856 public java.util.List<DB1> getDB1All() throws HL7Exception { 857 return getAllAsList("DB1", DB1.class); 858 } 859 860 /** 861 * <p> 862 * Inserts a specific repetition of DB1 (Disability) 863 * </p> 864 * 865 * 866 * @see AbstractGroup#insertRepetition(Structure, int) 867 */ 868 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 869 super.insertRepetition( "DB1", structure, rep); 870 } 871 872 873 /** 874 * <p> 875 * Inserts a specific repetition of DB1 (Disability) 876 * </p> 877 * 878 * 879 * @see AbstractGroup#insertRepetition(Structure, int) 880 */ 881 public DB1 insertDB1(int rep) throws HL7Exception { 882 return (DB1)super.insertRepetition("DB1", rep); 883 } 884 885 886 /** 887 * <p> 888 * Removes a specific repetition of DB1 (Disability) 889 * </p> 890 * 891 * 892 * @see AbstractGroup#removeRepetition(String, int) 893 */ 894 public DB1 removeDB1(int rep) throws HL7Exception { 895 return (DB1)super.removeRepetition("DB1", rep); 896 } 897 898 899 900 901 /** 902 * <p> 903 * Returns 904 * the first repetition of 905 * OBX (Observation/Result) - creates it if necessary 906 * </p> 907 * 908 * 909 */ 910 public OBX getOBX() { 911 return getTyped("OBX", OBX.class); 912 } 913 914 915 /** 916 * <p> 917 * Returns a specific repetition of 918 * OBX (Observation/Result) - creates it if necessary 919 * </p> 920 * 921 * 922 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 923 * @throws HL7Exception if the repetition requested is more than one 924 * greater than the number of existing repetitions. 925 */ 926 public OBX getOBX(int rep) { 927 return getTyped("OBX", rep, OBX.class); 928 } 929 930 /** 931 * <p> 932 * Returns the number of existing repetitions of OBX 933 * </p> 934 * 935 */ 936 public int getOBXReps() { 937 return getReps("OBX"); 938 } 939 940 /** 941 * <p> 942 * Returns a non-modifiable List containing all current existing repetitions of OBX. 943 * <p> 944 * <p> 945 * Note that unlike {@link #getOBX()}, this method will not create any reps 946 * if none are already present, so an empty list may be returned. 947 * </p> 948 * 949 */ 950 public java.util.List<OBX> getOBXAll() throws HL7Exception { 951 return getAllAsList("OBX", OBX.class); 952 } 953 954 /** 955 * <p> 956 * Inserts a specific repetition of OBX (Observation/Result) 957 * </p> 958 * 959 * 960 * @see AbstractGroup#insertRepetition(Structure, int) 961 */ 962 public void insertOBX(OBX structure, int rep) throws HL7Exception { 963 super.insertRepetition( "OBX", structure, rep); 964 } 965 966 967 /** 968 * <p> 969 * Inserts a specific repetition of OBX (Observation/Result) 970 * </p> 971 * 972 * 973 * @see AbstractGroup#insertRepetition(Structure, int) 974 */ 975 public OBX insertOBX(int rep) throws HL7Exception { 976 return (OBX)super.insertRepetition("OBX", rep); 977 } 978 979 980 /** 981 * <p> 982 * Removes a specific repetition of OBX (Observation/Result) 983 * </p> 984 * 985 * 986 * @see AbstractGroup#removeRepetition(String, int) 987 */ 988 public OBX removeOBX(int rep) throws HL7Exception { 989 return (OBX)super.removeRepetition("OBX", rep); 990 } 991 992 993 994 995 /** 996 * <p> 997 * Returns 998 * the first repetition of 999 * AL1 (Patient Allergy Information) - creates it if necessary 1000 * </p> 1001 * 1002 * 1003 */ 1004 public AL1 getAL1() { 1005 return getTyped("AL1", AL1.class); 1006 } 1007 1008 1009 /** 1010 * <p> 1011 * Returns a specific repetition of 1012 * AL1 (Patient Allergy Information) - creates it if necessary 1013 * </p> 1014 * 1015 * 1016 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1017 * @throws HL7Exception if the repetition requested is more than one 1018 * greater than the number of existing repetitions. 1019 */ 1020 public AL1 getAL1(int rep) { 1021 return getTyped("AL1", rep, AL1.class); 1022 } 1023 1024 /** 1025 * <p> 1026 * Returns the number of existing repetitions of AL1 1027 * </p> 1028 * 1029 */ 1030 public int getAL1Reps() { 1031 return getReps("AL1"); 1032 } 1033 1034 /** 1035 * <p> 1036 * Returns a non-modifiable List containing all current existing repetitions of AL1. 1037 * <p> 1038 * <p> 1039 * Note that unlike {@link #getAL1()}, this method will not create any reps 1040 * if none are already present, so an empty list may be returned. 1041 * </p> 1042 * 1043 */ 1044 public java.util.List<AL1> getAL1All() throws HL7Exception { 1045 return getAllAsList("AL1", AL1.class); 1046 } 1047 1048 /** 1049 * <p> 1050 * Inserts a specific repetition of AL1 (Patient Allergy Information) 1051 * </p> 1052 * 1053 * 1054 * @see AbstractGroup#insertRepetition(Structure, int) 1055 */ 1056 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 1057 super.insertRepetition( "AL1", structure, rep); 1058 } 1059 1060 1061 /** 1062 * <p> 1063 * Inserts a specific repetition of AL1 (Patient Allergy Information) 1064 * </p> 1065 * 1066 * 1067 * @see AbstractGroup#insertRepetition(Structure, int) 1068 */ 1069 public AL1 insertAL1(int rep) throws HL7Exception { 1070 return (AL1)super.insertRepetition("AL1", rep); 1071 } 1072 1073 1074 /** 1075 * <p> 1076 * Removes a specific repetition of AL1 (Patient Allergy Information) 1077 * </p> 1078 * 1079 * 1080 * @see AbstractGroup#removeRepetition(String, int) 1081 */ 1082 public AL1 removeAL1(int rep) throws HL7Exception { 1083 return (AL1)super.removeRepetition("AL1", rep); 1084 } 1085 1086 1087 1088 1089 /** 1090 * <p> 1091 * Returns 1092 * the first repetition of 1093 * DG1 (Diagnosis) - creates it if necessary 1094 * </p> 1095 * 1096 * 1097 */ 1098 public DG1 getDG1() { 1099 return getTyped("DG1", DG1.class); 1100 } 1101 1102 1103 /** 1104 * <p> 1105 * Returns a specific repetition of 1106 * DG1 (Diagnosis) - creates it if necessary 1107 * </p> 1108 * 1109 * 1110 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1111 * @throws HL7Exception if the repetition requested is more than one 1112 * greater than the number of existing repetitions. 1113 */ 1114 public DG1 getDG1(int rep) { 1115 return getTyped("DG1", rep, DG1.class); 1116 } 1117 1118 /** 1119 * <p> 1120 * Returns the number of existing repetitions of DG1 1121 * </p> 1122 * 1123 */ 1124 public int getDG1Reps() { 1125 return getReps("DG1"); 1126 } 1127 1128 /** 1129 * <p> 1130 * Returns a non-modifiable List containing all current existing repetitions of DG1. 1131 * <p> 1132 * <p> 1133 * Note that unlike {@link #getDG1()}, this method will not create any reps 1134 * if none are already present, so an empty list may be returned. 1135 * </p> 1136 * 1137 */ 1138 public java.util.List<DG1> getDG1All() throws HL7Exception { 1139 return getAllAsList("DG1", DG1.class); 1140 } 1141 1142 /** 1143 * <p> 1144 * Inserts a specific repetition of DG1 (Diagnosis) 1145 * </p> 1146 * 1147 * 1148 * @see AbstractGroup#insertRepetition(Structure, int) 1149 */ 1150 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 1151 super.insertRepetition( "DG1", structure, rep); 1152 } 1153 1154 1155 /** 1156 * <p> 1157 * Inserts a specific repetition of DG1 (Diagnosis) 1158 * </p> 1159 * 1160 * 1161 * @see AbstractGroup#insertRepetition(Structure, int) 1162 */ 1163 public DG1 insertDG1(int rep) throws HL7Exception { 1164 return (DG1)super.insertRepetition("DG1", rep); 1165 } 1166 1167 1168 /** 1169 * <p> 1170 * Removes a specific repetition of DG1 (Diagnosis) 1171 * </p> 1172 * 1173 * 1174 * @see AbstractGroup#removeRepetition(String, int) 1175 */ 1176 public DG1 removeDG1(int rep) throws HL7Exception { 1177 return (DG1)super.removeRepetition("DG1", rep); 1178 } 1179 1180 1181 1182 1183 /** 1184 * <p> 1185 * Returns 1186 * DRG (Diagnosis Related Group) - creates it if necessary 1187 * </p> 1188 * 1189 * 1190 */ 1191 public DRG getDRG() { 1192 return getTyped("DRG", DRG.class); 1193 } 1194 1195 1196 1197 1198 1199 /** 1200 * <p> 1201 * Returns 1202 * the first repetition of 1203 * PROCEDURE (a Group object) - creates it if necessary 1204 * </p> 1205 * 1206 * 1207 */ 1208 public ADT_A16_PROCEDURE getPROCEDURE() { 1209 return getTyped("PROCEDURE", ADT_A16_PROCEDURE.class); 1210 } 1211 1212 1213 /** 1214 * <p> 1215 * Returns a specific repetition of 1216 * PROCEDURE (a Group object) - creates it if necessary 1217 * </p> 1218 * 1219 * 1220 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1221 * @throws HL7Exception if the repetition requested is more than one 1222 * greater than the number of existing repetitions. 1223 */ 1224 public ADT_A16_PROCEDURE getPROCEDURE(int rep) { 1225 return getTyped("PROCEDURE", rep, ADT_A16_PROCEDURE.class); 1226 } 1227 1228 /** 1229 * <p> 1230 * Returns the number of existing repetitions of PROCEDURE 1231 * </p> 1232 * 1233 */ 1234 public int getPROCEDUREReps() { 1235 return getReps("PROCEDURE"); 1236 } 1237 1238 /** 1239 * <p> 1240 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 1241 * <p> 1242 * <p> 1243 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 1244 * if none are already present, so an empty list may be returned. 1245 * </p> 1246 * 1247 */ 1248 public java.util.List<ADT_A16_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 1249 return getAllAsList("PROCEDURE", ADT_A16_PROCEDURE.class); 1250 } 1251 1252 /** 1253 * <p> 1254 * Inserts a specific repetition of PROCEDURE (a Group object) 1255 * </p> 1256 * 1257 * 1258 * @see AbstractGroup#insertRepetition(Structure, int) 1259 */ 1260 public void insertPROCEDURE(ADT_A16_PROCEDURE structure, int rep) throws HL7Exception { 1261 super.insertRepetition( "PROCEDURE", structure, rep); 1262 } 1263 1264 1265 /** 1266 * <p> 1267 * Inserts a specific repetition of PROCEDURE (a Group object) 1268 * </p> 1269 * 1270 * 1271 * @see AbstractGroup#insertRepetition(Structure, int) 1272 */ 1273 public ADT_A16_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 1274 return (ADT_A16_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 1275 } 1276 1277 1278 /** 1279 * <p> 1280 * Removes a specific repetition of PROCEDURE (a Group object) 1281 * </p> 1282 * 1283 * 1284 * @see AbstractGroup#removeRepetition(String, int) 1285 */ 1286 public ADT_A16_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 1287 return (ADT_A16_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 1288 } 1289 1290 1291 1292 1293 /** 1294 * <p> 1295 * Returns 1296 * the first repetition of 1297 * GT1 (Guarantor) - creates it if necessary 1298 * </p> 1299 * 1300 * 1301 */ 1302 public GT1 getGT1() { 1303 return getTyped("GT1", GT1.class); 1304 } 1305 1306 1307 /** 1308 * <p> 1309 * Returns a specific repetition of 1310 * GT1 (Guarantor) - creates it if necessary 1311 * </p> 1312 * 1313 * 1314 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1315 * @throws HL7Exception if the repetition requested is more than one 1316 * greater than the number of existing repetitions. 1317 */ 1318 public GT1 getGT1(int rep) { 1319 return getTyped("GT1", rep, GT1.class); 1320 } 1321 1322 /** 1323 * <p> 1324 * Returns the number of existing repetitions of GT1 1325 * </p> 1326 * 1327 */ 1328 public int getGT1Reps() { 1329 return getReps("GT1"); 1330 } 1331 1332 /** 1333 * <p> 1334 * Returns a non-modifiable List containing all current existing repetitions of GT1. 1335 * <p> 1336 * <p> 1337 * Note that unlike {@link #getGT1()}, this method will not create any reps 1338 * if none are already present, so an empty list may be returned. 1339 * </p> 1340 * 1341 */ 1342 public java.util.List<GT1> getGT1All() throws HL7Exception { 1343 return getAllAsList("GT1", GT1.class); 1344 } 1345 1346 /** 1347 * <p> 1348 * Inserts a specific repetition of GT1 (Guarantor) 1349 * </p> 1350 * 1351 * 1352 * @see AbstractGroup#insertRepetition(Structure, int) 1353 */ 1354 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 1355 super.insertRepetition( "GT1", structure, rep); 1356 } 1357 1358 1359 /** 1360 * <p> 1361 * Inserts a specific repetition of GT1 (Guarantor) 1362 * </p> 1363 * 1364 * 1365 * @see AbstractGroup#insertRepetition(Structure, int) 1366 */ 1367 public GT1 insertGT1(int rep) throws HL7Exception { 1368 return (GT1)super.insertRepetition("GT1", rep); 1369 } 1370 1371 1372 /** 1373 * <p> 1374 * Removes a specific repetition of GT1 (Guarantor) 1375 * </p> 1376 * 1377 * 1378 * @see AbstractGroup#removeRepetition(String, int) 1379 */ 1380 public GT1 removeGT1(int rep) throws HL7Exception { 1381 return (GT1)super.removeRepetition("GT1", rep); 1382 } 1383 1384 1385 1386 1387 /** 1388 * <p> 1389 * Returns 1390 * the first repetition of 1391 * INSURANCE (a Group object) - creates it if necessary 1392 * </p> 1393 * 1394 * 1395 */ 1396 public ADT_A16_INSURANCE getINSURANCE() { 1397 return getTyped("INSURANCE", ADT_A16_INSURANCE.class); 1398 } 1399 1400 1401 /** 1402 * <p> 1403 * Returns a specific repetition of 1404 * INSURANCE (a Group object) - creates it if necessary 1405 * </p> 1406 * 1407 * 1408 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 1409 * @throws HL7Exception if the repetition requested is more than one 1410 * greater than the number of existing repetitions. 1411 */ 1412 public ADT_A16_INSURANCE getINSURANCE(int rep) { 1413 return getTyped("INSURANCE", rep, ADT_A16_INSURANCE.class); 1414 } 1415 1416 /** 1417 * <p> 1418 * Returns the number of existing repetitions of INSURANCE 1419 * </p> 1420 * 1421 */ 1422 public int getINSURANCEReps() { 1423 return getReps("INSURANCE"); 1424 } 1425 1426 /** 1427 * <p> 1428 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 1429 * <p> 1430 * <p> 1431 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 1432 * if none are already present, so an empty list may be returned. 1433 * </p> 1434 * 1435 */ 1436 public java.util.List<ADT_A16_INSURANCE> getINSURANCEAll() throws HL7Exception { 1437 return getAllAsList("INSURANCE", ADT_A16_INSURANCE.class); 1438 } 1439 1440 /** 1441 * <p> 1442 * Inserts a specific repetition of INSURANCE (a Group object) 1443 * </p> 1444 * 1445 * 1446 * @see AbstractGroup#insertRepetition(Structure, int) 1447 */ 1448 public void insertINSURANCE(ADT_A16_INSURANCE structure, int rep) throws HL7Exception { 1449 super.insertRepetition( "INSURANCE", structure, rep); 1450 } 1451 1452 1453 /** 1454 * <p> 1455 * Inserts a specific repetition of INSURANCE (a Group object) 1456 * </p> 1457 * 1458 * 1459 * @see AbstractGroup#insertRepetition(Structure, int) 1460 */ 1461 public ADT_A16_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 1462 return (ADT_A16_INSURANCE)super.insertRepetition("INSURANCE", rep); 1463 } 1464 1465 1466 /** 1467 * <p> 1468 * Removes a specific repetition of INSURANCE (a Group object) 1469 * </p> 1470 * 1471 * 1472 * @see AbstractGroup#removeRepetition(String, int) 1473 */ 1474 public ADT_A16_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 1475 return (ADT_A16_INSURANCE)super.removeRepetition("INSURANCE", rep); 1476 } 1477 1478 1479 1480 1481 /** 1482 * <p> 1483 * Returns 1484 * ACC (Accident) - creates it if necessary 1485 * </p> 1486 * 1487 * 1488 */ 1489 public ACC getACC() { 1490 return getTyped("ACC", ACC.class); 1491 } 1492 1493 1494 1495 1496} 1497