1 /* 2 * This class is an auto-generated source file for a HAPI 3 * HL7 v2.x standard structure class. 4 * 5 * For more information, visit: http://hl7api.sourceforge.net/ 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 1.1 8 * (the "License"); you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 10 * Software distributed under the License is distributed on an "AS IS" basis, 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 12 * specific language governing rights and limitations under the License. 13 * 14 * The Original Code is "[file_name]". Description: 15 * "[one_line_description]" 16 * 17 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 18 * 2012. All Rights Reserved. 19 * 20 * Contributor(s): ______________________________________. 21 * 22 * Alternatively, the contents of this file may be used under the terms of the 23 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 24 * applicable instead of those above. If you wish to allow use of your version of this 25 * file only under the terms of the GPL and not to allow others to use your version 26 * of this file under the MPL, indicate your decision by deleting the provisions above 27 * and replace them with the notice and other provisions required by the GPL License. 28 * If you do not delete the provisions above, a recipient may use your version of 29 * this file under either the MPL or the GPL. 30 * 31 */ 32 33 34 package ca.uhn.hl7v2.model.v281.message; 35 36 import ca.uhn.hl7v2.model.v281.group.*; 37 import ca.uhn.hl7v2.model.v281.segment.*; 38 39 import ca.uhn.hl7v2.HL7Exception; 40 import ca.uhn.hl7v2.parser.ModelClassFactory; 41 import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 42 import ca.uhn.hl7v2.model.*; 43 44 45 /** 46 * <p>Represents a EHC_E01 message structure (see chapter 16.3.1). This structure contains the 47 * following elements: </p> 48 * <ul> 49 * <li>1: MSH (Message Header) <b> </b> </li> 50 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li> 51 * <li>3: UAC (User Authentication Credential Segment) <b>optional repeating</b> </li> 52 * <li>4: IVC (Invoice Segment) <b> </b> </li> 53 * <li>5: PYE (Payee Information) <b>optional </b> </li> 54 * <li>6: CTD (Contact Data) <b>optional repeating</b> </li> 55 * <li>7: AUT (Authorization Information) <b>optional </b> </li> 56 * <li>8: LOC (Location Identification) <b>optional repeating</b> </li> 57 * <li>9: PRT (Participation Information) <b>optional repeating</b> </li> 58 * <li>10: ROL (Role) <b>optional repeating</b> </li> 59 * <li>11: EHC_E01_PRODUCT_SERVICE_SECTION (a Group object) <b> repeating</b> </li> 60 * </ul> 61 */ 62 //@SuppressWarnings("unused") 63 public class EHC_E01 extends AbstractMessage { 64 65 /** 66 * Creates a new EHC_E01 message with DefaultModelClassFactory. 67 */ 68 public EHC_E01() { 69 this(new DefaultModelClassFactory()); 70 } 71 72 /** 73 * Creates a new EHC_E01 message with custom ModelClassFactory. 74 */ 75 public EHC_E01(ModelClassFactory factory) { 76 super(factory); 77 init(factory); 78 } 79 80 private void init(ModelClassFactory factory) { 81 try { 82 this.add(MSH.class, true, false); 83 this.add(SFT.class, false, true); 84 this.add(UAC.class, false, true); 85 this.add(IVC.class, true, false); 86 this.add(PYE.class, false, false); 87 this.add(CTD.class, false, true); 88 this.add(AUT.class, false, false); 89 this.add(LOC.class, false, true); 90 this.add(PRT.class, false, true); 91 this.add(ROL.class, false, true); 92 this.add(EHC_E01_PRODUCT_SERVICE_SECTION.class, true, true); 93 } catch(HL7Exception e) { 94 log.error("Unexpected error creating EHC_E01 - this is probably a bug in the source code generator.", e); 95 } 96 } 97 98 99 /** 100 * Returns "2.8.1" 101 */ 102 public String getVersion() { 103 return "2.8.1"; 104 } 105 106 107 108 109 /** 110 * <p> 111 * Returns 112 * MSH (Message Header) - creates it if necessary 113 * </p> 114 * 115 * 116 */ 117 public MSH getMSH() { 118 return getTyped("MSH", MSH.class); 119 } 120 121 122 123 124 125 /** 126 * <p> 127 * Returns 128 * the first repetition of 129 * SFT (Software Segment) - creates it if necessary 130 * </p> 131 * 132 * 133 */ 134 public SFT getSFT() { 135 return getTyped("SFT", SFT.class); 136 } 137 138 139 /** 140 * <p> 141 * Returns a specific repetition of 142 * SFT (Software Segment) - creates it if necessary 143 * </p> 144 * 145 * 146 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 147 * @throws HL7Exception if the repetition requested is more than one 148 * greater than the number of existing repetitions. 149 */ 150 public SFT getSFT(int rep) { 151 return getTyped("SFT", rep, SFT.class); 152 } 153 154 /** 155 * <p> 156 * Returns the number of existing repetitions of SFT 157 * </p> 158 * 159 */ 160 public int getSFTReps() { 161 return getReps("SFT"); 162 } 163 164 /** 165 * <p> 166 * Returns a non-modifiable List containing all current existing repetitions of SFT. 167 * <p> 168 * <p> 169 * Note that unlike {@link #getSFT()}, this method will not create any reps 170 * if none are already present, so an empty list may be returned. 171 * </p> 172 * 173 */ 174 public java.util.List<SFT> getSFTAll() throws HL7Exception { 175 return getAllAsList("SFT", SFT.class); 176 } 177 178 /** 179 * <p> 180 * Inserts a specific repetition of SFT (Software Segment) 181 * </p> 182 * 183 * 184 * @see AbstractGroup#insertRepetition(Structure, int) 185 */ 186 public void insertSFT(SFT structure, int rep) throws HL7Exception { 187 super.insertRepetition( "SFT", structure, rep); 188 } 189 190 191 /** 192 * <p> 193 * Inserts a specific repetition of SFT (Software Segment) 194 * </p> 195 * 196 * 197 * @see AbstractGroup#insertRepetition(Structure, int) 198 */ 199 public SFT insertSFT(int rep) throws HL7Exception { 200 return (SFT)super.insertRepetition("SFT", rep); 201 } 202 203 204 /** 205 * <p> 206 * Removes a specific repetition of SFT (Software Segment) 207 * </p> 208 * 209 * 210 * @see AbstractGroup#removeRepetition(String, int) 211 */ 212 public SFT removeSFT(int rep) throws HL7Exception { 213 return (SFT)super.removeRepetition("SFT", rep); 214 } 215 216 217 218 219 /** 220 * <p> 221 * Returns 222 * the first repetition of 223 * UAC (User Authentication Credential Segment) - creates it if necessary 224 * </p> 225 * 226 * 227 */ 228 public UAC getUAC() { 229 return getTyped("UAC", UAC.class); 230 } 231 232 233 /** 234 * <p> 235 * Returns a specific repetition of 236 * UAC (User Authentication Credential Segment) - creates it if necessary 237 * </p> 238 * 239 * 240 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 241 * @throws HL7Exception if the repetition requested is more than one 242 * greater than the number of existing repetitions. 243 */ 244 public UAC getUAC(int rep) { 245 return getTyped("UAC", rep, UAC.class); 246 } 247 248 /** 249 * <p> 250 * Returns the number of existing repetitions of UAC 251 * </p> 252 * 253 */ 254 public int getUACReps() { 255 return getReps("UAC"); 256 } 257 258 /** 259 * <p> 260 * Returns a non-modifiable List containing all current existing repetitions of UAC. 261 * <p> 262 * <p> 263 * Note that unlike {@link #getUAC()}, this method will not create any reps 264 * if none are already present, so an empty list may be returned. 265 * </p> 266 * 267 */ 268 public java.util.List<UAC> getUACAll() throws HL7Exception { 269 return getAllAsList("UAC", UAC.class); 270 } 271 272 /** 273 * <p> 274 * Inserts a specific repetition of UAC (User Authentication Credential Segment) 275 * </p> 276 * 277 * 278 * @see AbstractGroup#insertRepetition(Structure, int) 279 */ 280 public void insertUAC(UAC structure, int rep) throws HL7Exception { 281 super.insertRepetition( "UAC", structure, rep); 282 } 283 284 285 /** 286 * <p> 287 * Inserts a specific repetition of UAC (User Authentication Credential Segment) 288 * </p> 289 * 290 * 291 * @see AbstractGroup#insertRepetition(Structure, int) 292 */ 293 public UAC insertUAC(int rep) throws HL7Exception { 294 return (UAC)super.insertRepetition("UAC", rep); 295 } 296 297 298 /** 299 * <p> 300 * Removes a specific repetition of UAC (User Authentication Credential Segment) 301 * </p> 302 * 303 * 304 * @see AbstractGroup#removeRepetition(String, int) 305 */ 306 public UAC removeUAC(int rep) throws HL7Exception { 307 return (UAC)super.removeRepetition("UAC", rep); 308 } 309 310 311 312 313 /** 314 * <p> 315 * Returns 316 * IVC (Invoice Segment) - creates it if necessary 317 * </p> 318 * 319 * 320 */ 321 public IVC getIVC() { 322 return getTyped("IVC", IVC.class); 323 } 324 325 326 327 328 329 /** 330 * <p> 331 * Returns 332 * PYE (Payee Information) - creates it if necessary 333 * </p> 334 * 335 * 336 */ 337 public PYE getPYE() { 338 return getTyped("PYE", PYE.class); 339 } 340 341 342 343 344 345 /** 346 * <p> 347 * Returns 348 * the first repetition of 349 * CTD (Contact Data) - creates it if necessary 350 * </p> 351 * 352 * 353 */ 354 public CTD getCTD() { 355 return getTyped("CTD", CTD.class); 356 } 357 358 359 /** 360 * <p> 361 * Returns a specific repetition of 362 * CTD (Contact Data) - creates it if necessary 363 * </p> 364 * 365 * 366 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 367 * @throws HL7Exception if the repetition requested is more than one 368 * greater than the number of existing repetitions. 369 */ 370 public CTD getCTD(int rep) { 371 return getTyped("CTD", rep, CTD.class); 372 } 373 374 /** 375 * <p> 376 * Returns the number of existing repetitions of CTD 377 * </p> 378 * 379 */ 380 public int getCTDReps() { 381 return getReps("CTD"); 382 } 383 384 /** 385 * <p> 386 * Returns a non-modifiable List containing all current existing repetitions of CTD. 387 * <p> 388 * <p> 389 * Note that unlike {@link #getCTD()}, this method will not create any reps 390 * if none are already present, so an empty list may be returned. 391 * </p> 392 * 393 */ 394 public java.util.List<CTD> getCTDAll() throws HL7Exception { 395 return getAllAsList("CTD", CTD.class); 396 } 397 398 /** 399 * <p> 400 * Inserts a specific repetition of CTD (Contact Data) 401 * </p> 402 * 403 * 404 * @see AbstractGroup#insertRepetition(Structure, int) 405 */ 406 public void insertCTD(CTD structure, int rep) throws HL7Exception { 407 super.insertRepetition( "CTD", structure, rep); 408 } 409 410 411 /** 412 * <p> 413 * Inserts a specific repetition of CTD (Contact Data) 414 * </p> 415 * 416 * 417 * @see AbstractGroup#insertRepetition(Structure, int) 418 */ 419 public CTD insertCTD(int rep) throws HL7Exception { 420 return (CTD)super.insertRepetition("CTD", rep); 421 } 422 423 424 /** 425 * <p> 426 * Removes a specific repetition of CTD (Contact Data) 427 * </p> 428 * 429 * 430 * @see AbstractGroup#removeRepetition(String, int) 431 */ 432 public CTD removeCTD(int rep) throws HL7Exception { 433 return (CTD)super.removeRepetition("CTD", rep); 434 } 435 436 437 438 439 /** 440 * <p> 441 * Returns 442 * AUT (Authorization Information) - creates it if necessary 443 * </p> 444 * 445 * 446 */ 447 public AUT getAUT() { 448 return getTyped("AUT", AUT.class); 449 } 450 451 452 453 454 455 /** 456 * <p> 457 * Returns 458 * the first repetition of 459 * LOC (Location Identification) - creates it if necessary 460 * </p> 461 * 462 * 463 */ 464 public LOC getLOC() { 465 return getTyped("LOC", LOC.class); 466 } 467 468 469 /** 470 * <p> 471 * Returns a specific repetition of 472 * LOC (Location Identification) - creates it if necessary 473 * </p> 474 * 475 * 476 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 477 * @throws HL7Exception if the repetition requested is more than one 478 * greater than the number of existing repetitions. 479 */ 480 public LOC getLOC(int rep) { 481 return getTyped("LOC", rep, LOC.class); 482 } 483 484 /** 485 * <p> 486 * Returns the number of existing repetitions of LOC 487 * </p> 488 * 489 */ 490 public int getLOCReps() { 491 return getReps("LOC"); 492 } 493 494 /** 495 * <p> 496 * Returns a non-modifiable List containing all current existing repetitions of LOC. 497 * <p> 498 * <p> 499 * Note that unlike {@link #getLOC()}, this method will not create any reps 500 * if none are already present, so an empty list may be returned. 501 * </p> 502 * 503 */ 504 public java.util.List<LOC> getLOCAll() throws HL7Exception { 505 return getAllAsList("LOC", LOC.class); 506 } 507 508 /** 509 * <p> 510 * Inserts a specific repetition of LOC (Location Identification) 511 * </p> 512 * 513 * 514 * @see AbstractGroup#insertRepetition(Structure, int) 515 */ 516 public void insertLOC(LOC structure, int rep) throws HL7Exception { 517 super.insertRepetition( "LOC", structure, rep); 518 } 519 520 521 /** 522 * <p> 523 * Inserts a specific repetition of LOC (Location Identification) 524 * </p> 525 * 526 * 527 * @see AbstractGroup#insertRepetition(Structure, int) 528 */ 529 public LOC insertLOC(int rep) throws HL7Exception { 530 return (LOC)super.insertRepetition("LOC", rep); 531 } 532 533 534 /** 535 * <p> 536 * Removes a specific repetition of LOC (Location Identification) 537 * </p> 538 * 539 * 540 * @see AbstractGroup#removeRepetition(String, int) 541 */ 542 public LOC removeLOC(int rep) throws HL7Exception { 543 return (LOC)super.removeRepetition("LOC", rep); 544 } 545 546 547 548 549 /** 550 * <p> 551 * Returns 552 * the first repetition of 553 * PRT (Participation Information) - creates it if necessary 554 * </p> 555 * 556 * 557 */ 558 public PRT getPRT() { 559 return getTyped("PRT", PRT.class); 560 } 561 562 563 /** 564 * <p> 565 * Returns a specific repetition of 566 * PRT (Participation Information) - creates it if necessary 567 * </p> 568 * 569 * 570 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 571 * @throws HL7Exception if the repetition requested is more than one 572 * greater than the number of existing repetitions. 573 */ 574 public PRT getPRT(int rep) { 575 return getTyped("PRT", rep, PRT.class); 576 } 577 578 /** 579 * <p> 580 * Returns the number of existing repetitions of PRT 581 * </p> 582 * 583 */ 584 public int getPRTReps() { 585 return getReps("PRT"); 586 } 587 588 /** 589 * <p> 590 * Returns a non-modifiable List containing all current existing repetitions of PRT. 591 * <p> 592 * <p> 593 * Note that unlike {@link #getPRT()}, this method will not create any reps 594 * if none are already present, so an empty list may be returned. 595 * </p> 596 * 597 */ 598 public java.util.List<PRT> getPRTAll() throws HL7Exception { 599 return getAllAsList("PRT", PRT.class); 600 } 601 602 /** 603 * <p> 604 * Inserts a specific repetition of PRT (Participation Information) 605 * </p> 606 * 607 * 608 * @see AbstractGroup#insertRepetition(Structure, int) 609 */ 610 public void insertPRT(PRT structure, int rep) throws HL7Exception { 611 super.insertRepetition( "PRT", structure, rep); 612 } 613 614 615 /** 616 * <p> 617 * Inserts a specific repetition of PRT (Participation Information) 618 * </p> 619 * 620 * 621 * @see AbstractGroup#insertRepetition(Structure, int) 622 */ 623 public PRT insertPRT(int rep) throws HL7Exception { 624 return (PRT)super.insertRepetition("PRT", rep); 625 } 626 627 628 /** 629 * <p> 630 * Removes a specific repetition of PRT (Participation Information) 631 * </p> 632 * 633 * 634 * @see AbstractGroup#removeRepetition(String, int) 635 */ 636 public PRT removePRT(int rep) throws HL7Exception { 637 return (PRT)super.removeRepetition("PRT", rep); 638 } 639 640 641 642 643 /** 644 * <p> 645 * Returns 646 * the first repetition of 647 * ROL (Role) - creates it if necessary 648 * </p> 649 * 650 * 651 */ 652 public ROL getROL() { 653 return getTyped("ROL", ROL.class); 654 } 655 656 657 /** 658 * <p> 659 * Returns a specific repetition of 660 * ROL (Role) - creates it if necessary 661 * </p> 662 * 663 * 664 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 665 * @throws HL7Exception if the repetition requested is more than one 666 * greater than the number of existing repetitions. 667 */ 668 public ROL getROL(int rep) { 669 return getTyped("ROL", rep, ROL.class); 670 } 671 672 /** 673 * <p> 674 * Returns the number of existing repetitions of ROL 675 * </p> 676 * 677 */ 678 public int getROLReps() { 679 return getReps("ROL"); 680 } 681 682 /** 683 * <p> 684 * Returns a non-modifiable List containing all current existing repetitions of ROL. 685 * <p> 686 * <p> 687 * Note that unlike {@link #getROL()}, this method will not create any reps 688 * if none are already present, so an empty list may be returned. 689 * </p> 690 * 691 */ 692 public java.util.List<ROL> getROLAll() throws HL7Exception { 693 return getAllAsList("ROL", ROL.class); 694 } 695 696 /** 697 * <p> 698 * Inserts a specific repetition of ROL (Role) 699 * </p> 700 * 701 * 702 * @see AbstractGroup#insertRepetition(Structure, int) 703 */ 704 public void insertROL(ROL structure, int rep) throws HL7Exception { 705 super.insertRepetition( "ROL", structure, rep); 706 } 707 708 709 /** 710 * <p> 711 * Inserts a specific repetition of ROL (Role) 712 * </p> 713 * 714 * 715 * @see AbstractGroup#insertRepetition(Structure, int) 716 */ 717 public ROL insertROL(int rep) throws HL7Exception { 718 return (ROL)super.insertRepetition("ROL", rep); 719 } 720 721 722 /** 723 * <p> 724 * Removes a specific repetition of ROL (Role) 725 * </p> 726 * 727 * 728 * @see AbstractGroup#removeRepetition(String, int) 729 */ 730 public ROL removeROL(int rep) throws HL7Exception { 731 return (ROL)super.removeRepetition("ROL", rep); 732 } 733 734 735 736 737 /** 738 * <p> 739 * Returns 740 * the first repetition of 741 * PRODUCT_SERVICE_SECTION (a Group object) - creates it if necessary 742 * </p> 743 * 744 * 745 */ 746 public EHC_E01_PRODUCT_SERVICE_SECTION getPRODUCT_SERVICE_SECTION() { 747 return getTyped("PRODUCT_SERVICE_SECTION", EHC_E01_PRODUCT_SERVICE_SECTION.class); 748 } 749 750 751 /** 752 * <p> 753 * Returns a specific repetition of 754 * PRODUCT_SERVICE_SECTION (a Group object) - creates it if necessary 755 * </p> 756 * 757 * 758 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 759 * @throws HL7Exception if the repetition requested is more than one 760 * greater than the number of existing repetitions. 761 */ 762 public EHC_E01_PRODUCT_SERVICE_SECTION getPRODUCT_SERVICE_SECTION(int rep) { 763 return getTyped("PRODUCT_SERVICE_SECTION", rep, EHC_E01_PRODUCT_SERVICE_SECTION.class); 764 } 765 766 /** 767 * <p> 768 * Returns the number of existing repetitions of PRODUCT_SERVICE_SECTION 769 * </p> 770 * 771 */ 772 public int getPRODUCT_SERVICE_SECTIONReps() { 773 return getReps("PRODUCT_SERVICE_SECTION"); 774 } 775 776 /** 777 * <p> 778 * Returns a non-modifiable List containing all current existing repetitions of PRODUCT_SERVICE_SECTION. 779 * <p> 780 * <p> 781 * Note that unlike {@link #getPRODUCT_SERVICE_SECTION()}, this method will not create any reps 782 * if none are already present, so an empty list may be returned. 783 * </p> 784 * 785 */ 786 public java.util.List<EHC_E01_PRODUCT_SERVICE_SECTION> getPRODUCT_SERVICE_SECTIONAll() throws HL7Exception { 787 return getAllAsList("PRODUCT_SERVICE_SECTION", EHC_E01_PRODUCT_SERVICE_SECTION.class); 788 } 789 790 /** 791 * <p> 792 * Inserts a specific repetition of PRODUCT_SERVICE_SECTION (a Group object) 793 * </p> 794 * 795 * 796 * @see AbstractGroup#insertRepetition(Structure, int) 797 */ 798 public void insertPRODUCT_SERVICE_SECTION(EHC_E01_PRODUCT_SERVICE_SECTION structure, int rep) throws HL7Exception { 799 super.insertRepetition( "PRODUCT_SERVICE_SECTION", structure, rep); 800 } 801 802 803 /** 804 * <p> 805 * Inserts a specific repetition of PRODUCT_SERVICE_SECTION (a Group object) 806 * </p> 807 * 808 * 809 * @see AbstractGroup#insertRepetition(Structure, int) 810 */ 811 public EHC_E01_PRODUCT_SERVICE_SECTION insertPRODUCT_SERVICE_SECTION(int rep) throws HL7Exception { 812 return (EHC_E01_PRODUCT_SERVICE_SECTION)super.insertRepetition("PRODUCT_SERVICE_SECTION", rep); 813 } 814 815 816 /** 817 * <p> 818 * Removes a specific repetition of PRODUCT_SERVICE_SECTION (a Group object) 819 * </p> 820 * 821 * 822 * @see AbstractGroup#removeRepetition(String, int) 823 */ 824 public EHC_E01_PRODUCT_SERVICE_SECTION removePRODUCT_SERVICE_SECTION(int rep) throws HL7Exception { 825 return (EHC_E01_PRODUCT_SERVICE_SECTION)super.removeRepetition("PRODUCT_SERVICE_SECTION", rep); 826 } 827 828 829 830 } 831