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