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