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