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