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.v251.group; 035 036import ca.uhn.hl7v2.model.v251.segment.*; 037 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.model.*; 041 042/** 043 * <p>Represents a ADR_A19_QUERY_RESPONSE group structure (a Group object). 044 * A Group is an ordered collection of message segments that can repeat together or be optionally in/excluded together. 045 * This Group contains the following elements: 046 * </p> 047 * <ul> 048 * <li>1: EVN (Event Type) <b>optional </b></li> 049 * <li>2: PID (Patient Identification) <b> </b></li> 050 * <li>3: PD1 (Patient Additional Demographic) <b>optional </b></li> 051 * <li>4: ROL (Role) <b>optional repeating </b></li> 052 * <li>5: NK1 (Next of Kin / Associated Parties) <b>optional repeating </b></li> 053 * <li>6: PV1 (Patient Visit) <b> </b></li> 054 * <li>7: PV2 (Patient Visit - Additional Information) <b>optional </b></li> 055 * <li>8: ROL (Role) <b>optional repeating </b></li> 056 * <li>9: DB1 (Disability) <b>optional repeating </b></li> 057 * <li>10: OBX (Observation/Result) <b>optional repeating </b></li> 058 * <li>11: AL1 (Patient Allergy Information) <b>optional repeating </b></li> 059 * <li>12: DG1 (Diagnosis) <b>optional repeating </b></li> 060 * <li>13: DRG (Diagnosis Related Group) <b>optional </b></li> 061 * <li>14: ADR_A19_PROCEDURE (a Group object) <b>optional repeating </b></li> 062 * <li>15: GT1 (Guarantor) <b>optional repeating </b></li> 063 * <li>16: ADR_A19_INSURANCE (a Group object) <b>optional repeating </b></li> 064 * <li>17: ACC (Accident) <b>optional </b></li> 065 * <li>18: UB1 (UB82) <b>optional </b></li> 066 * <li>19: UB2 (UB92 Data) <b>optional </b></li> 067 * </ul> 068 */ 069//@SuppressWarnings("unused") 070public class ADR_A19_QUERY_RESPONSE extends AbstractGroup { 071 072 /** 073 * Creates a new ADR_A19_QUERY_RESPONSE group 074 */ 075 public ADR_A19_QUERY_RESPONSE(Group parent, ModelClassFactory factory) { 076 super(parent, factory); 077 init(factory); 078 } 079 080 private void init(ModelClassFactory factory) { 081 try { 082 this.add(EVN.class, false, false, false); 083 this.add(PID.class, true, false, false); 084 this.add(PD1.class, false, false, false); 085 this.add(ROL.class, false, true, false); 086 this.add(NK1.class, false, true, false); 087 this.add(PV1.class, true, false, false); 088 this.add(PV2.class, false, false, false); 089 this.add(ROL.class, false, true, false); 090 this.add(DB1.class, false, true, false); 091 this.add(OBX.class, false, true, false); 092 this.add(AL1.class, false, true, false); 093 this.add(DG1.class, false, true, false); 094 this.add(DRG.class, false, false, false); 095 this.add(ADR_A19_PROCEDURE.class, false, true, false); 096 this.add(GT1.class, false, true, false); 097 this.add(ADR_A19_INSURANCE.class, false, true, false); 098 this.add(ACC.class, false, false, false); 099 this.add(UB1.class, false, false, false); 100 this.add(UB2.class, false, false, false); 101 } catch(HL7Exception e) { 102 log.error("Unexpected error creating ADR_A19_QUERY_RESPONSE - this is probably a bug in the source code generator.", e); 103 } 104 } 105 106 /** 107 * Returns "2.5.1" 108 */ 109 public String getVersion() { 110 return "2.5.1"; 111 } 112 113 114 115 /** 116 * Returns 117 * EVN (Event Type) - creates it if necessary 118 */ 119 public EVN getEVN() { 120 EVN retVal = getTyped("EVN", EVN.class); 121 return retVal; 122 } 123 124 125 126 127 /** 128 * Returns 129 * PID (Patient Identification) - creates it if necessary 130 */ 131 public PID getPID() { 132 PID retVal = getTyped("PID", PID.class); 133 return retVal; 134 } 135 136 137 138 139 /** 140 * Returns 141 * PD1 (Patient Additional Demographic) - creates it if necessary 142 */ 143 public PD1 getPD1() { 144 PD1 retVal = getTyped("PD1", PD1.class); 145 return retVal; 146 } 147 148 149 150 151 /** 152 * Returns 153 * the first repetition of 154 * ROL (Role) - creates it if necessary 155 */ 156 public ROL getROL() { 157 ROL retVal = getTyped("ROL", ROL.class); 158 return retVal; 159 } 160 161 162 /** 163 * Returns a specific repetition of 164 * ROL (Role) - creates it if necessary 165 * 166 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 167 * @throws HL7Exception if the repetition requested is more than one 168 * greater than the number of existing repetitions. 169 */ 170 public ROL getROL(int rep) { 171 ROL retVal = getTyped("ROL", rep, ROL.class); 172 return retVal; 173 } 174 175 /** 176 * Returns the number of existing repetitions of ROL 177 */ 178 public int getROLReps() { 179 return getReps("ROL"); 180 } 181 182 /** 183 * <p> 184 * Returns a non-modifiable List containing all current existing repetitions of ROL. 185 * <p> 186 * <p> 187 * Note that unlike {@link #getROL()}, this method will not create any reps 188 * if none are already present, so an empty list may be returned. 189 * </p> 190 */ 191 public java.util.List<ROL> getROLAll() throws HL7Exception { 192 return getAllAsList("ROL", ROL.class); 193 } 194 195 /** 196 * Inserts a specific repetition of ROL (Role) 197 * @see AbstractGroup#insertRepetition(Structure, int) 198 */ 199 public void insertROL(ROL structure, int rep) throws HL7Exception { 200 super.insertRepetition("ROL", structure, rep); 201 } 202 203 204 /** 205 * Inserts a specific repetition of ROL (Role) 206 * @see AbstractGroup#insertRepetition(Structure, int) 207 */ 208 public ROL insertROL(int rep) throws HL7Exception { 209 return (ROL)super.insertRepetition("ROL", rep); 210 } 211 212 213 /** 214 * Removes a specific repetition of ROL (Role) 215 * @see AbstractGroup#removeRepetition(String, int) 216 */ 217 public ROL removeROL(int rep) throws HL7Exception { 218 return (ROL)super.removeRepetition("ROL", rep); 219 } 220 221 222 223 /** 224 * Returns 225 * the first repetition of 226 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 227 */ 228 public NK1 getNK1() { 229 NK1 retVal = getTyped("NK1", NK1.class); 230 return retVal; 231 } 232 233 234 /** 235 * Returns a specific repetition of 236 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 237 * 238 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 239 * @throws HL7Exception if the repetition requested is more than one 240 * greater than the number of existing repetitions. 241 */ 242 public NK1 getNK1(int rep) { 243 NK1 retVal = getTyped("NK1", rep, NK1.class); 244 return retVal; 245 } 246 247 /** 248 * Returns the number of existing repetitions of NK1 249 */ 250 public int getNK1Reps() { 251 return getReps("NK1"); 252 } 253 254 /** 255 * <p> 256 * Returns a non-modifiable List containing all current existing repetitions of NK1. 257 * <p> 258 * <p> 259 * Note that unlike {@link #getNK1()}, this method will not create any reps 260 * if none are already present, so an empty list may be returned. 261 * </p> 262 */ 263 public java.util.List<NK1> getNK1All() throws HL7Exception { 264 return getAllAsList("NK1", NK1.class); 265 } 266 267 /** 268 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 269 * @see AbstractGroup#insertRepetition(Structure, int) 270 */ 271 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 272 super.insertRepetition("NK1", structure, rep); 273 } 274 275 276 /** 277 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 278 * @see AbstractGroup#insertRepetition(Structure, int) 279 */ 280 public NK1 insertNK1(int rep) throws HL7Exception { 281 return (NK1)super.insertRepetition("NK1", rep); 282 } 283 284 285 /** 286 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties) 287 * @see AbstractGroup#removeRepetition(String, int) 288 */ 289 public NK1 removeNK1(int rep) throws HL7Exception { 290 return (NK1)super.removeRepetition("NK1", rep); 291 } 292 293 294 295 /** 296 * Returns 297 * PV1 (Patient Visit) - creates it if necessary 298 */ 299 public PV1 getPV1() { 300 PV1 retVal = getTyped("PV1", PV1.class); 301 return retVal; 302 } 303 304 305 306 307 /** 308 * Returns 309 * PV2 (Patient Visit - Additional Information) - creates it if necessary 310 */ 311 public PV2 getPV2() { 312 PV2 retVal = getTyped("PV2", PV2.class); 313 return retVal; 314 } 315 316 317 318 319 /** 320 * Returns 321 * the first repetition of 322 * ROL2 (Role) - creates it if necessary 323 */ 324 public ROL getROL2() { 325 ROL retVal = getTyped("ROL2", ROL.class); 326 return retVal; 327 } 328 329 330 /** 331 * Returns a specific repetition of 332 * ROL (Role) - creates it if necessary 333 * 334 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 335 * @throws HL7Exception if the repetition requested is more than one 336 * greater than the number of existing repetitions. 337 */ 338 public ROL getROL2(int rep) { 339 ROL retVal = getTyped("ROL2", rep, ROL.class); 340 return retVal; 341 } 342 343 /** 344 * Returns the number of existing repetitions of ROL2 345 */ 346 public int getROL2Reps() { 347 return getReps("ROL2"); 348 } 349 350 /** 351 * <p> 352 * Returns a non-modifiable List containing all current existing repetitions of ROL2. 353 * <p> 354 * <p> 355 * Note that unlike {@link #getROL2()}, this method will not create any reps 356 * if none are already present, so an empty list may be returned. 357 * </p> 358 */ 359 public java.util.List<ROL> getROL2All() throws HL7Exception { 360 return getAllAsList("ROL2", ROL.class); 361 } 362 363 /** 364 * Inserts a specific repetition of ROL2 (Role) 365 * @see AbstractGroup#insertRepetition(Structure, int) 366 */ 367 public void insertROL2(ROL structure, int rep) throws HL7Exception { 368 super.insertRepetition("ROL2", structure, rep); 369 } 370 371 372 /** 373 * Inserts a specific repetition of ROL2 (Role) 374 * @see AbstractGroup#insertRepetition(Structure, int) 375 */ 376 public ROL insertROL2(int rep) throws HL7Exception { 377 return (ROL)super.insertRepetition("ROL2", rep); 378 } 379 380 381 /** 382 * Removes a specific repetition of ROL2 (Role) 383 * @see AbstractGroup#removeRepetition(String, int) 384 */ 385 public ROL removeROL2(int rep) throws HL7Exception { 386 return (ROL)super.removeRepetition("ROL2", rep); 387 } 388 389 390 391 /** 392 * Returns 393 * the first repetition of 394 * DB1 (Disability) - creates it if necessary 395 */ 396 public DB1 getDB1() { 397 DB1 retVal = getTyped("DB1", DB1.class); 398 return retVal; 399 } 400 401 402 /** 403 * Returns a specific repetition of 404 * DB1 (Disability) - creates it if necessary 405 * 406 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 407 * @throws HL7Exception if the repetition requested is more than one 408 * greater than the number of existing repetitions. 409 */ 410 public DB1 getDB1(int rep) { 411 DB1 retVal = getTyped("DB1", rep, DB1.class); 412 return retVal; 413 } 414 415 /** 416 * Returns the number of existing repetitions of DB1 417 */ 418 public int getDB1Reps() { 419 return getReps("DB1"); 420 } 421 422 /** 423 * <p> 424 * Returns a non-modifiable List containing all current existing repetitions of DB1. 425 * <p> 426 * <p> 427 * Note that unlike {@link #getDB1()}, this method will not create any reps 428 * if none are already present, so an empty list may be returned. 429 * </p> 430 */ 431 public java.util.List<DB1> getDB1All() throws HL7Exception { 432 return getAllAsList("DB1", DB1.class); 433 } 434 435 /** 436 * Inserts a specific repetition of DB1 (Disability) 437 * @see AbstractGroup#insertRepetition(Structure, int) 438 */ 439 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 440 super.insertRepetition("DB1", structure, rep); 441 } 442 443 444 /** 445 * Inserts a specific repetition of DB1 (Disability) 446 * @see AbstractGroup#insertRepetition(Structure, int) 447 */ 448 public DB1 insertDB1(int rep) throws HL7Exception { 449 return (DB1)super.insertRepetition("DB1", rep); 450 } 451 452 453 /** 454 * Removes a specific repetition of DB1 (Disability) 455 * @see AbstractGroup#removeRepetition(String, int) 456 */ 457 public DB1 removeDB1(int rep) throws HL7Exception { 458 return (DB1)super.removeRepetition("DB1", rep); 459 } 460 461 462 463 /** 464 * Returns 465 * the first repetition of 466 * OBX (Observation/Result) - creates it if necessary 467 */ 468 public OBX getOBX() { 469 OBX retVal = getTyped("OBX", OBX.class); 470 return retVal; 471 } 472 473 474 /** 475 * Returns a specific repetition of 476 * OBX (Observation/Result) - creates it if necessary 477 * 478 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 479 * @throws HL7Exception if the repetition requested is more than one 480 * greater than the number of existing repetitions. 481 */ 482 public OBX getOBX(int rep) { 483 OBX retVal = getTyped("OBX", rep, OBX.class); 484 return retVal; 485 } 486 487 /** 488 * Returns the number of existing repetitions of OBX 489 */ 490 public int getOBXReps() { 491 return getReps("OBX"); 492 } 493 494 /** 495 * <p> 496 * Returns a non-modifiable List containing all current existing repetitions of OBX. 497 * <p> 498 * <p> 499 * Note that unlike {@link #getOBX()}, this method will not create any reps 500 * if none are already present, so an empty list may be returned. 501 * </p> 502 */ 503 public java.util.List<OBX> getOBXAll() throws HL7Exception { 504 return getAllAsList("OBX", OBX.class); 505 } 506 507 /** 508 * Inserts a specific repetition of OBX (Observation/Result) 509 * @see AbstractGroup#insertRepetition(Structure, int) 510 */ 511 public void insertOBX(OBX structure, int rep) throws HL7Exception { 512 super.insertRepetition("OBX", structure, rep); 513 } 514 515 516 /** 517 * Inserts a specific repetition of OBX (Observation/Result) 518 * @see AbstractGroup#insertRepetition(Structure, int) 519 */ 520 public OBX insertOBX(int rep) throws HL7Exception { 521 return (OBX)super.insertRepetition("OBX", rep); 522 } 523 524 525 /** 526 * Removes a specific repetition of OBX (Observation/Result) 527 * @see AbstractGroup#removeRepetition(String, int) 528 */ 529 public OBX removeOBX(int rep) throws HL7Exception { 530 return (OBX)super.removeRepetition("OBX", rep); 531 } 532 533 534 535 /** 536 * Returns 537 * the first repetition of 538 * AL1 (Patient Allergy Information) - creates it if necessary 539 */ 540 public AL1 getAL1() { 541 AL1 retVal = getTyped("AL1", AL1.class); 542 return retVal; 543 } 544 545 546 /** 547 * Returns a specific repetition of 548 * AL1 (Patient Allergy Information) - creates it if necessary 549 * 550 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 551 * @throws HL7Exception if the repetition requested is more than one 552 * greater than the number of existing repetitions. 553 */ 554 public AL1 getAL1(int rep) { 555 AL1 retVal = getTyped("AL1", rep, AL1.class); 556 return retVal; 557 } 558 559 /** 560 * Returns the number of existing repetitions of AL1 561 */ 562 public int getAL1Reps() { 563 return getReps("AL1"); 564 } 565 566 /** 567 * <p> 568 * Returns a non-modifiable List containing all current existing repetitions of AL1. 569 * <p> 570 * <p> 571 * Note that unlike {@link #getAL1()}, this method will not create any reps 572 * if none are already present, so an empty list may be returned. 573 * </p> 574 */ 575 public java.util.List<AL1> getAL1All() throws HL7Exception { 576 return getAllAsList("AL1", AL1.class); 577 } 578 579 /** 580 * Inserts a specific repetition of AL1 (Patient Allergy Information) 581 * @see AbstractGroup#insertRepetition(Structure, int) 582 */ 583 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 584 super.insertRepetition("AL1", structure, rep); 585 } 586 587 588 /** 589 * Inserts a specific repetition of AL1 (Patient Allergy Information) 590 * @see AbstractGroup#insertRepetition(Structure, int) 591 */ 592 public AL1 insertAL1(int rep) throws HL7Exception { 593 return (AL1)super.insertRepetition("AL1", rep); 594 } 595 596 597 /** 598 * Removes a specific repetition of AL1 (Patient Allergy Information) 599 * @see AbstractGroup#removeRepetition(String, int) 600 */ 601 public AL1 removeAL1(int rep) throws HL7Exception { 602 return (AL1)super.removeRepetition("AL1", rep); 603 } 604 605 606 607 /** 608 * Returns 609 * the first repetition of 610 * DG1 (Diagnosis) - creates it if necessary 611 */ 612 public DG1 getDG1() { 613 DG1 retVal = getTyped("DG1", DG1.class); 614 return retVal; 615 } 616 617 618 /** 619 * Returns a specific repetition of 620 * DG1 (Diagnosis) - creates it if necessary 621 * 622 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 623 * @throws HL7Exception if the repetition requested is more than one 624 * greater than the number of existing repetitions. 625 */ 626 public DG1 getDG1(int rep) { 627 DG1 retVal = getTyped("DG1", rep, DG1.class); 628 return retVal; 629 } 630 631 /** 632 * Returns the number of existing repetitions of DG1 633 */ 634 public int getDG1Reps() { 635 return getReps("DG1"); 636 } 637 638 /** 639 * <p> 640 * Returns a non-modifiable List containing all current existing repetitions of DG1. 641 * <p> 642 * <p> 643 * Note that unlike {@link #getDG1()}, this method will not create any reps 644 * if none are already present, so an empty list may be returned. 645 * </p> 646 */ 647 public java.util.List<DG1> getDG1All() throws HL7Exception { 648 return getAllAsList("DG1", DG1.class); 649 } 650 651 /** 652 * Inserts a specific repetition of DG1 (Diagnosis) 653 * @see AbstractGroup#insertRepetition(Structure, int) 654 */ 655 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 656 super.insertRepetition("DG1", structure, rep); 657 } 658 659 660 /** 661 * Inserts a specific repetition of DG1 (Diagnosis) 662 * @see AbstractGroup#insertRepetition(Structure, int) 663 */ 664 public DG1 insertDG1(int rep) throws HL7Exception { 665 return (DG1)super.insertRepetition("DG1", rep); 666 } 667 668 669 /** 670 * Removes a specific repetition of DG1 (Diagnosis) 671 * @see AbstractGroup#removeRepetition(String, int) 672 */ 673 public DG1 removeDG1(int rep) throws HL7Exception { 674 return (DG1)super.removeRepetition("DG1", rep); 675 } 676 677 678 679 /** 680 * Returns 681 * DRG (Diagnosis Related Group) - creates it if necessary 682 */ 683 public DRG getDRG() { 684 DRG retVal = getTyped("DRG", DRG.class); 685 return retVal; 686 } 687 688 689 690 691 /** 692 * Returns 693 * the first repetition of 694 * PROCEDURE (a Group object) - creates it if necessary 695 */ 696 public ADR_A19_PROCEDURE getPROCEDURE() { 697 ADR_A19_PROCEDURE retVal = getTyped("PROCEDURE", ADR_A19_PROCEDURE.class); 698 return retVal; 699 } 700 701 702 /** 703 * Returns a specific repetition of 704 * PROCEDURE (a Group object) - creates it if necessary 705 * 706 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 707 * @throws HL7Exception if the repetition requested is more than one 708 * greater than the number of existing repetitions. 709 */ 710 public ADR_A19_PROCEDURE getPROCEDURE(int rep) { 711 ADR_A19_PROCEDURE retVal = getTyped("PROCEDURE", rep, ADR_A19_PROCEDURE.class); 712 return retVal; 713 } 714 715 /** 716 * Returns the number of existing repetitions of PROCEDURE 717 */ 718 public int getPROCEDUREReps() { 719 return getReps("PROCEDURE"); 720 } 721 722 /** 723 * <p> 724 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 725 * <p> 726 * <p> 727 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 728 * if none are already present, so an empty list may be returned. 729 * </p> 730 */ 731 public java.util.List<ADR_A19_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 732 return getAllAsList("PROCEDURE", ADR_A19_PROCEDURE.class); 733 } 734 735 /** 736 * Inserts a specific repetition of PROCEDURE (a Group object) 737 * @see AbstractGroup#insertRepetition(Structure, int) 738 */ 739 public void insertPROCEDURE(ADR_A19_PROCEDURE structure, int rep) throws HL7Exception { 740 super.insertRepetition("PROCEDURE", structure, rep); 741 } 742 743 744 /** 745 * Inserts a specific repetition of PROCEDURE (a Group object) 746 * @see AbstractGroup#insertRepetition(Structure, int) 747 */ 748 public ADR_A19_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 749 return (ADR_A19_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 750 } 751 752 753 /** 754 * Removes a specific repetition of PROCEDURE (a Group object) 755 * @see AbstractGroup#removeRepetition(String, int) 756 */ 757 public ADR_A19_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 758 return (ADR_A19_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 759 } 760 761 762 763 /** 764 * Returns 765 * the first repetition of 766 * GT1 (Guarantor) - creates it if necessary 767 */ 768 public GT1 getGT1() { 769 GT1 retVal = getTyped("GT1", GT1.class); 770 return retVal; 771 } 772 773 774 /** 775 * Returns a specific repetition of 776 * GT1 (Guarantor) - creates it if necessary 777 * 778 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 779 * @throws HL7Exception if the repetition requested is more than one 780 * greater than the number of existing repetitions. 781 */ 782 public GT1 getGT1(int rep) { 783 GT1 retVal = getTyped("GT1", rep, GT1.class); 784 return retVal; 785 } 786 787 /** 788 * Returns the number of existing repetitions of GT1 789 */ 790 public int getGT1Reps() { 791 return getReps("GT1"); 792 } 793 794 /** 795 * <p> 796 * Returns a non-modifiable List containing all current existing repetitions of GT1. 797 * <p> 798 * <p> 799 * Note that unlike {@link #getGT1()}, this method will not create any reps 800 * if none are already present, so an empty list may be returned. 801 * </p> 802 */ 803 public java.util.List<GT1> getGT1All() throws HL7Exception { 804 return getAllAsList("GT1", GT1.class); 805 } 806 807 /** 808 * Inserts a specific repetition of GT1 (Guarantor) 809 * @see AbstractGroup#insertRepetition(Structure, int) 810 */ 811 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 812 super.insertRepetition("GT1", structure, rep); 813 } 814 815 816 /** 817 * Inserts a specific repetition of GT1 (Guarantor) 818 * @see AbstractGroup#insertRepetition(Structure, int) 819 */ 820 public GT1 insertGT1(int rep) throws HL7Exception { 821 return (GT1)super.insertRepetition("GT1", rep); 822 } 823 824 825 /** 826 * Removes a specific repetition of GT1 (Guarantor) 827 * @see AbstractGroup#removeRepetition(String, int) 828 */ 829 public GT1 removeGT1(int rep) throws HL7Exception { 830 return (GT1)super.removeRepetition("GT1", rep); 831 } 832 833 834 835 /** 836 * Returns 837 * the first repetition of 838 * INSURANCE (a Group object) - creates it if necessary 839 */ 840 public ADR_A19_INSURANCE getINSURANCE() { 841 ADR_A19_INSURANCE retVal = getTyped("INSURANCE", ADR_A19_INSURANCE.class); 842 return retVal; 843 } 844 845 846 /** 847 * Returns a specific repetition of 848 * INSURANCE (a Group object) - creates it if necessary 849 * 850 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 851 * @throws HL7Exception if the repetition requested is more than one 852 * greater than the number of existing repetitions. 853 */ 854 public ADR_A19_INSURANCE getINSURANCE(int rep) { 855 ADR_A19_INSURANCE retVal = getTyped("INSURANCE", rep, ADR_A19_INSURANCE.class); 856 return retVal; 857 } 858 859 /** 860 * Returns the number of existing repetitions of INSURANCE 861 */ 862 public int getINSURANCEReps() { 863 return getReps("INSURANCE"); 864 } 865 866 /** 867 * <p> 868 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 869 * <p> 870 * <p> 871 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 872 * if none are already present, so an empty list may be returned. 873 * </p> 874 */ 875 public java.util.List<ADR_A19_INSURANCE> getINSURANCEAll() throws HL7Exception { 876 return getAllAsList("INSURANCE", ADR_A19_INSURANCE.class); 877 } 878 879 /** 880 * Inserts a specific repetition of INSURANCE (a Group object) 881 * @see AbstractGroup#insertRepetition(Structure, int) 882 */ 883 public void insertINSURANCE(ADR_A19_INSURANCE structure, int rep) throws HL7Exception { 884 super.insertRepetition("INSURANCE", structure, rep); 885 } 886 887 888 /** 889 * Inserts a specific repetition of INSURANCE (a Group object) 890 * @see AbstractGroup#insertRepetition(Structure, int) 891 */ 892 public ADR_A19_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 893 return (ADR_A19_INSURANCE)super.insertRepetition("INSURANCE", rep); 894 } 895 896 897 /** 898 * Removes a specific repetition of INSURANCE (a Group object) 899 * @see AbstractGroup#removeRepetition(String, int) 900 */ 901 public ADR_A19_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 902 return (ADR_A19_INSURANCE)super.removeRepetition("INSURANCE", rep); 903 } 904 905 906 907 /** 908 * Returns 909 * ACC (Accident) - creates it if necessary 910 */ 911 public ACC getACC() { 912 ACC retVal = getTyped("ACC", ACC.class); 913 return retVal; 914 } 915 916 917 918 919 /** 920 * Returns 921 * UB1 (UB82) - creates it if necessary 922 */ 923 public UB1 getUB1() { 924 UB1 retVal = getTyped("UB1", UB1.class); 925 return retVal; 926 } 927 928 929 930 931 /** 932 * Returns 933 * UB2 (UB92 Data) - creates it if necessary 934 */ 935 public UB2 getUB2() { 936 UB2 retVal = getTyped("UB2", UB2.class); 937 return retVal; 938 } 939 940 941 942 943} 944