1 /* 2 * This class is an auto-generated source file for a HAPI 3 * HL7 v2.x standard structure class. 4 * 5 * For more information, visit: http://hl7api.sourceforge.net/ 6 * 7 * The contents of this file are subject to the Mozilla Public License Version 1.1 8 * (the "License"); you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 10 * Software distributed under the License is distributed on an "AS IS" basis, 11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 12 * specific language governing rights and limitations under the License. 13 * 14 * The Original Code is "[file_name]". Description: 15 * "[one_line_description]" 16 * 17 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 18 * 2012. All Rights Reserved. 19 * 20 * Contributor(s): ______________________________________. 21 * 22 * Alternatively, the contents of this file may be used under the terms of the 23 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 24 * applicable instead of those above. If you wish to allow use of your version of this 25 * file only under the terms of the GPL and not to allow others to use your version 26 * of this file under the MPL, indicate your decision by deleting the provisions above 27 * and replace them with the notice and other provisions required by the GPL License. 28 * If you do not delete the provisions above, a recipient may use your version of 29 * this file under either the MPL or the GPL. 30 * 31 */ 32 33 34 package ca.uhn.hl7v2.model.v26.group; 35 36 import ca.uhn.hl7v2.model.v26.segment.*; 37 38 import ca.uhn.hl7v2.HL7Exception; 39 import ca.uhn.hl7v2.parser.ModelClassFactory; 40 import ca.uhn.hl7v2.model.*; 41 42 /** 43 * <p>Represents a ADR_A19_QUERY_RESPONSE group structure (a Group object). 44 * A Group is an ordered collection of message segments that can repeat together or be optionally in/excluded together. 45 * This Group contains the following elements: 46 * </p> 47 * <ul> 48 * <li>1: EVN (Event Type) <b>optional </b></li> 49 * <li>2: PID (Patient Identification) <b> </b></li> 50 * <li>3: PD1 (Patient Additional Demographic) <b>optional </b></li> 51 * <li>4: ARV (Access Restriction) <b>optional repeating </b></li> 52 * <li>5: ROL (Role) <b>optional repeating </b></li> 53 * <li>6: NK1 (Next of Kin / Associated Parties) <b>optional repeating </b></li> 54 * <li>7: PV1 (Patient Visit) <b> </b></li> 55 * <li>8: PV2 (Patient Visit - Additional Information) <b>optional </b></li> 56 * <li>9: ARV (Access Restriction) <b>optional repeating </b></li> 57 * <li>10: ROL (Role) <b>optional repeating </b></li> 58 * <li>11: DB1 (Disability) <b>optional repeating </b></li> 59 * <li>12: OBX (Observation/Result) <b>optional repeating </b></li> 60 * <li>13: AL1 (Patient Allergy Information) <b>optional repeating </b></li> 61 * <li>14: DG1 (Diagnosis) <b>optional repeating </b></li> 62 * <li>15: DRG (Diagnosis Related Group) <b>optional </b></li> 63 * <li>16: ADR_A19_PROCEDURE (a Group object) <b>optional repeating </b></li> 64 * <li>17: GT1 (Guarantor) <b>optional repeating </b></li> 65 * <li>18: ADR_A19_INSURANCE (a Group object) <b>optional repeating </b></li> 66 * <li>19: ACC (Accident) <b>optional </b></li> 67 * <li>20: UB1 (UB82) <b>optional </b></li> 68 * <li>21: UB2 (UB92 Data) <b>optional </b></li> 69 * </ul> 70 */ 71 //@SuppressWarnings("unused") 72 public class ADR_A19_QUERY_RESPONSE extends AbstractGroup { 73 74 /** 75 * Creates a new ADR_A19_QUERY_RESPONSE group 76 */ 77 public ADR_A19_QUERY_RESPONSE(Group parent, ModelClassFactory factory) { 78 super(parent, factory); 79 init(factory); 80 } 81 82 private void init(ModelClassFactory factory) { 83 try { 84 this.add(EVN.class, false, false, false); 85 this.add(PID.class, true, false, false); 86 this.add(PD1.class, false, false, false); 87 this.add(ARV.class, false, true, false); 88 this.add(ROL.class, false, true, false); 89 this.add(NK1.class, false, true, false); 90 this.add(PV1.class, true, false, false); 91 this.add(PV2.class, false, false, false); 92 this.add(ARV.class, false, true, false); 93 this.add(ROL.class, false, true, false); 94 this.add(DB1.class, false, true, false); 95 this.add(OBX.class, false, true, false); 96 this.add(AL1.class, false, true, false); 97 this.add(DG1.class, false, true, false); 98 this.add(DRG.class, false, false, false); 99 this.add(ADR_A19_PROCEDURE.class, false, true, false); 100 this.add(GT1.class, false, true, false); 101 this.add(ADR_A19_INSURANCE.class, false, true, false); 102 this.add(ACC.class, false, false, false); 103 this.add(UB1.class, false, false, false); 104 this.add(UB2.class, false, false, false); 105 } catch(HL7Exception e) { 106 log.error("Unexpected error creating ADR_A19_QUERY_RESPONSE - this is probably a bug in the source code generator.", e); 107 } 108 } 109 110 /** 111 * Returns "2.6" 112 */ 113 public String getVersion() { 114 return "2.6"; 115 } 116 117 118 119 /** 120 * Returns 121 * EVN (Event Type) - creates it if necessary 122 */ 123 public EVN getEVN() { 124 EVN retVal = getTyped("EVN", EVN.class); 125 return retVal; 126 } 127 128 129 130 131 /** 132 * Returns 133 * PID (Patient Identification) - creates it if necessary 134 */ 135 public PID getPID() { 136 PID retVal = getTyped("PID", PID.class); 137 return retVal; 138 } 139 140 141 142 143 /** 144 * Returns 145 * PD1 (Patient Additional Demographic) - creates it if necessary 146 */ 147 public PD1 getPD1() { 148 PD1 retVal = getTyped("PD1", PD1.class); 149 return retVal; 150 } 151 152 153 154 155 /** 156 * Returns 157 * the first repetition of 158 * ARV (Access Restriction) - creates it if necessary 159 */ 160 public ARV getARV() { 161 ARV retVal = getTyped("ARV", ARV.class); 162 return retVal; 163 } 164 165 166 /** 167 * Returns a specific repetition of 168 * ARV (Access Restriction) - creates it if necessary 169 * 170 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 171 * @throws HL7Exception if the repetition requested is more than one 172 * greater than the number of existing repetitions. 173 */ 174 public ARV getARV(int rep) { 175 ARV retVal = getTyped("ARV", rep, ARV.class); 176 return retVal; 177 } 178 179 /** 180 * Returns the number of existing repetitions of ARV 181 */ 182 public int getARVReps() { 183 return getReps("ARV"); 184 } 185 186 /** 187 * <p> 188 * Returns a non-modifiable List containing all current existing repetitions of ARV. 189 * <p> 190 * <p> 191 * Note that unlike {@link #getARV()}, this method will not create any reps 192 * if none are already present, so an empty list may be returned. 193 * </p> 194 */ 195 public java.util.List<ARV> getARVAll() throws HL7Exception { 196 return getAllAsList("ARV", ARV.class); 197 } 198 199 /** 200 * Inserts a specific repetition of ARV (Access Restriction) 201 * @see AbstractGroup#insertRepetition(Structure, int) 202 */ 203 public void insertARV(ARV structure, int rep) throws HL7Exception { 204 super.insertRepetition("ARV", structure, rep); 205 } 206 207 208 /** 209 * Inserts a specific repetition of ARV (Access Restriction) 210 * @see AbstractGroup#insertRepetition(Structure, int) 211 */ 212 public ARV insertARV(int rep) throws HL7Exception { 213 return (ARV)super.insertRepetition("ARV", rep); 214 } 215 216 217 /** 218 * Removes a specific repetition of ARV (Access Restriction) 219 * @see AbstractGroup#removeRepetition(String, int) 220 */ 221 public ARV removeARV(int rep) throws HL7Exception { 222 return (ARV)super.removeRepetition("ARV", rep); 223 } 224 225 226 227 /** 228 * Returns 229 * the first repetition of 230 * ROL (Role) - creates it if necessary 231 */ 232 public ROL getROL() { 233 ROL retVal = getTyped("ROL", ROL.class); 234 return retVal; 235 } 236 237 238 /** 239 * Returns a specific repetition of 240 * ROL (Role) - creates it if necessary 241 * 242 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 243 * @throws HL7Exception if the repetition requested is more than one 244 * greater than the number of existing repetitions. 245 */ 246 public ROL getROL(int rep) { 247 ROL retVal = getTyped("ROL", rep, ROL.class); 248 return retVal; 249 } 250 251 /** 252 * Returns the number of existing repetitions of ROL 253 */ 254 public int getROLReps() { 255 return getReps("ROL"); 256 } 257 258 /** 259 * <p> 260 * Returns a non-modifiable List containing all current existing repetitions of ROL. 261 * <p> 262 * <p> 263 * Note that unlike {@link #getROL()}, this method will not create any reps 264 * if none are already present, so an empty list may be returned. 265 * </p> 266 */ 267 public java.util.List<ROL> getROLAll() throws HL7Exception { 268 return getAllAsList("ROL", ROL.class); 269 } 270 271 /** 272 * Inserts a specific repetition of ROL (Role) 273 * @see AbstractGroup#insertRepetition(Structure, int) 274 */ 275 public void insertROL(ROL structure, int rep) throws HL7Exception { 276 super.insertRepetition("ROL", structure, rep); 277 } 278 279 280 /** 281 * Inserts a specific repetition of ROL (Role) 282 * @see AbstractGroup#insertRepetition(Structure, int) 283 */ 284 public ROL insertROL(int rep) throws HL7Exception { 285 return (ROL)super.insertRepetition("ROL", rep); 286 } 287 288 289 /** 290 * Removes a specific repetition of ROL (Role) 291 * @see AbstractGroup#removeRepetition(String, int) 292 */ 293 public ROL removeROL(int rep) throws HL7Exception { 294 return (ROL)super.removeRepetition("ROL", rep); 295 } 296 297 298 299 /** 300 * Returns 301 * the first repetition of 302 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 303 */ 304 public NK1 getNK1() { 305 NK1 retVal = getTyped("NK1", NK1.class); 306 return retVal; 307 } 308 309 310 /** 311 * Returns a specific repetition of 312 * NK1 (Next of Kin / Associated Parties) - creates it if necessary 313 * 314 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 315 * @throws HL7Exception if the repetition requested is more than one 316 * greater than the number of existing repetitions. 317 */ 318 public NK1 getNK1(int rep) { 319 NK1 retVal = getTyped("NK1", rep, NK1.class); 320 return retVal; 321 } 322 323 /** 324 * Returns the number of existing repetitions of NK1 325 */ 326 public int getNK1Reps() { 327 return getReps("NK1"); 328 } 329 330 /** 331 * <p> 332 * Returns a non-modifiable List containing all current existing repetitions of NK1. 333 * <p> 334 * <p> 335 * Note that unlike {@link #getNK1()}, this method will not create any reps 336 * if none are already present, so an empty list may be returned. 337 * </p> 338 */ 339 public java.util.List<NK1> getNK1All() throws HL7Exception { 340 return getAllAsList("NK1", NK1.class); 341 } 342 343 /** 344 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 345 * @see AbstractGroup#insertRepetition(Structure, int) 346 */ 347 public void insertNK1(NK1 structure, int rep) throws HL7Exception { 348 super.insertRepetition("NK1", structure, rep); 349 } 350 351 352 /** 353 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties) 354 * @see AbstractGroup#insertRepetition(Structure, int) 355 */ 356 public NK1 insertNK1(int rep) throws HL7Exception { 357 return (NK1)super.insertRepetition("NK1", rep); 358 } 359 360 361 /** 362 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties) 363 * @see AbstractGroup#removeRepetition(String, int) 364 */ 365 public NK1 removeNK1(int rep) throws HL7Exception { 366 return (NK1)super.removeRepetition("NK1", rep); 367 } 368 369 370 371 /** 372 * Returns 373 * PV1 (Patient Visit) - creates it if necessary 374 */ 375 public PV1 getPV1() { 376 PV1 retVal = getTyped("PV1", PV1.class); 377 return retVal; 378 } 379 380 381 382 383 /** 384 * Returns 385 * PV2 (Patient Visit - Additional Information) - creates it if necessary 386 */ 387 public PV2 getPV2() { 388 PV2 retVal = getTyped("PV2", PV2.class); 389 return retVal; 390 } 391 392 393 394 395 /** 396 * Returns 397 * the first repetition of 398 * ARV2 (Access Restriction) - creates it if necessary 399 */ 400 public ARV getARV2() { 401 ARV retVal = getTyped("ARV2", ARV.class); 402 return retVal; 403 } 404 405 406 /** 407 * Returns a specific repetition of 408 * ARV (Access Restriction) - creates it if necessary 409 * 410 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 411 * @throws HL7Exception if the repetition requested is more than one 412 * greater than the number of existing repetitions. 413 */ 414 public ARV getARV2(int rep) { 415 ARV retVal = getTyped("ARV2", rep, ARV.class); 416 return retVal; 417 } 418 419 /** 420 * Returns the number of existing repetitions of ARV2 421 */ 422 public int getARV2Reps() { 423 return getReps("ARV2"); 424 } 425 426 /** 427 * <p> 428 * Returns a non-modifiable List containing all current existing repetitions of ARV2. 429 * <p> 430 * <p> 431 * Note that unlike {@link #getARV2()}, this method will not create any reps 432 * if none are already present, so an empty list may be returned. 433 * </p> 434 */ 435 public java.util.List<ARV> getARV2All() throws HL7Exception { 436 return getAllAsList("ARV2", ARV.class); 437 } 438 439 /** 440 * Inserts a specific repetition of ARV2 (Access Restriction) 441 * @see AbstractGroup#insertRepetition(Structure, int) 442 */ 443 public void insertARV2(ARV structure, int rep) throws HL7Exception { 444 super.insertRepetition("ARV2", structure, rep); 445 } 446 447 448 /** 449 * Inserts a specific repetition of ARV2 (Access Restriction) 450 * @see AbstractGroup#insertRepetition(Structure, int) 451 */ 452 public ARV insertARV2(int rep) throws HL7Exception { 453 return (ARV)super.insertRepetition("ARV2", rep); 454 } 455 456 457 /** 458 * Removes a specific repetition of ARV2 (Access Restriction) 459 * @see AbstractGroup#removeRepetition(String, int) 460 */ 461 public ARV removeARV2(int rep) throws HL7Exception { 462 return (ARV)super.removeRepetition("ARV2", rep); 463 } 464 465 466 467 /** 468 * Returns 469 * the first repetition of 470 * ROL2 (Role) - creates it if necessary 471 */ 472 public ROL getROL2() { 473 ROL retVal = getTyped("ROL2", ROL.class); 474 return retVal; 475 } 476 477 478 /** 479 * Returns a specific repetition of 480 * ROL (Role) - creates it if necessary 481 * 482 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 483 * @throws HL7Exception if the repetition requested is more than one 484 * greater than the number of existing repetitions. 485 */ 486 public ROL getROL2(int rep) { 487 ROL retVal = getTyped("ROL2", rep, ROL.class); 488 return retVal; 489 } 490 491 /** 492 * Returns the number of existing repetitions of ROL2 493 */ 494 public int getROL2Reps() { 495 return getReps("ROL2"); 496 } 497 498 /** 499 * <p> 500 * Returns a non-modifiable List containing all current existing repetitions of ROL2. 501 * <p> 502 * <p> 503 * Note that unlike {@link #getROL2()}, this method will not create any reps 504 * if none are already present, so an empty list may be returned. 505 * </p> 506 */ 507 public java.util.List<ROL> getROL2All() throws HL7Exception { 508 return getAllAsList("ROL2", ROL.class); 509 } 510 511 /** 512 * Inserts a specific repetition of ROL2 (Role) 513 * @see AbstractGroup#insertRepetition(Structure, int) 514 */ 515 public void insertROL2(ROL structure, int rep) throws HL7Exception { 516 super.insertRepetition("ROL2", structure, rep); 517 } 518 519 520 /** 521 * Inserts a specific repetition of ROL2 (Role) 522 * @see AbstractGroup#insertRepetition(Structure, int) 523 */ 524 public ROL insertROL2(int rep) throws HL7Exception { 525 return (ROL)super.insertRepetition("ROL2", rep); 526 } 527 528 529 /** 530 * Removes a specific repetition of ROL2 (Role) 531 * @see AbstractGroup#removeRepetition(String, int) 532 */ 533 public ROL removeROL2(int rep) throws HL7Exception { 534 return (ROL)super.removeRepetition("ROL2", rep); 535 } 536 537 538 539 /** 540 * Returns 541 * the first repetition of 542 * DB1 (Disability) - creates it if necessary 543 */ 544 public DB1 getDB1() { 545 DB1 retVal = getTyped("DB1", DB1.class); 546 return retVal; 547 } 548 549 550 /** 551 * Returns a specific repetition of 552 * DB1 (Disability) - creates it if necessary 553 * 554 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 555 * @throws HL7Exception if the repetition requested is more than one 556 * greater than the number of existing repetitions. 557 */ 558 public DB1 getDB1(int rep) { 559 DB1 retVal = getTyped("DB1", rep, DB1.class); 560 return retVal; 561 } 562 563 /** 564 * Returns the number of existing repetitions of DB1 565 */ 566 public int getDB1Reps() { 567 return getReps("DB1"); 568 } 569 570 /** 571 * <p> 572 * Returns a non-modifiable List containing all current existing repetitions of DB1. 573 * <p> 574 * <p> 575 * Note that unlike {@link #getDB1()}, this method will not create any reps 576 * if none are already present, so an empty list may be returned. 577 * </p> 578 */ 579 public java.util.List<DB1> getDB1All() throws HL7Exception { 580 return getAllAsList("DB1", DB1.class); 581 } 582 583 /** 584 * Inserts a specific repetition of DB1 (Disability) 585 * @see AbstractGroup#insertRepetition(Structure, int) 586 */ 587 public void insertDB1(DB1 structure, int rep) throws HL7Exception { 588 super.insertRepetition("DB1", structure, rep); 589 } 590 591 592 /** 593 * Inserts a specific repetition of DB1 (Disability) 594 * @see AbstractGroup#insertRepetition(Structure, int) 595 */ 596 public DB1 insertDB1(int rep) throws HL7Exception { 597 return (DB1)super.insertRepetition("DB1", rep); 598 } 599 600 601 /** 602 * Removes a specific repetition of DB1 (Disability) 603 * @see AbstractGroup#removeRepetition(String, int) 604 */ 605 public DB1 removeDB1(int rep) throws HL7Exception { 606 return (DB1)super.removeRepetition("DB1", rep); 607 } 608 609 610 611 /** 612 * Returns 613 * the first repetition of 614 * OBX (Observation/Result) - creates it if necessary 615 */ 616 public OBX getOBX() { 617 OBX retVal = getTyped("OBX", OBX.class); 618 return retVal; 619 } 620 621 622 /** 623 * Returns a specific repetition of 624 * OBX (Observation/Result) - creates it if necessary 625 * 626 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 627 * @throws HL7Exception if the repetition requested is more than one 628 * greater than the number of existing repetitions. 629 */ 630 public OBX getOBX(int rep) { 631 OBX retVal = getTyped("OBX", rep, OBX.class); 632 return retVal; 633 } 634 635 /** 636 * Returns the number of existing repetitions of OBX 637 */ 638 public int getOBXReps() { 639 return getReps("OBX"); 640 } 641 642 /** 643 * <p> 644 * Returns a non-modifiable List containing all current existing repetitions of OBX. 645 * <p> 646 * <p> 647 * Note that unlike {@link #getOBX()}, this method will not create any reps 648 * if none are already present, so an empty list may be returned. 649 * </p> 650 */ 651 public java.util.List<OBX> getOBXAll() throws HL7Exception { 652 return getAllAsList("OBX", OBX.class); 653 } 654 655 /** 656 * Inserts a specific repetition of OBX (Observation/Result) 657 * @see AbstractGroup#insertRepetition(Structure, int) 658 */ 659 public void insertOBX(OBX structure, int rep) throws HL7Exception { 660 super.insertRepetition("OBX", structure, rep); 661 } 662 663 664 /** 665 * Inserts a specific repetition of OBX (Observation/Result) 666 * @see AbstractGroup#insertRepetition(Structure, int) 667 */ 668 public OBX insertOBX(int rep) throws HL7Exception { 669 return (OBX)super.insertRepetition("OBX", rep); 670 } 671 672 673 /** 674 * Removes a specific repetition of OBX (Observation/Result) 675 * @see AbstractGroup#removeRepetition(String, int) 676 */ 677 public OBX removeOBX(int rep) throws HL7Exception { 678 return (OBX)super.removeRepetition("OBX", rep); 679 } 680 681 682 683 /** 684 * Returns 685 * the first repetition of 686 * AL1 (Patient Allergy Information) - creates it if necessary 687 */ 688 public AL1 getAL1() { 689 AL1 retVal = getTyped("AL1", AL1.class); 690 return retVal; 691 } 692 693 694 /** 695 * Returns a specific repetition of 696 * AL1 (Patient Allergy Information) - creates it if necessary 697 * 698 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 699 * @throws HL7Exception if the repetition requested is more than one 700 * greater than the number of existing repetitions. 701 */ 702 public AL1 getAL1(int rep) { 703 AL1 retVal = getTyped("AL1", rep, AL1.class); 704 return retVal; 705 } 706 707 /** 708 * Returns the number of existing repetitions of AL1 709 */ 710 public int getAL1Reps() { 711 return getReps("AL1"); 712 } 713 714 /** 715 * <p> 716 * Returns a non-modifiable List containing all current existing repetitions of AL1. 717 * <p> 718 * <p> 719 * Note that unlike {@link #getAL1()}, this method will not create any reps 720 * if none are already present, so an empty list may be returned. 721 * </p> 722 */ 723 public java.util.List<AL1> getAL1All() throws HL7Exception { 724 return getAllAsList("AL1", AL1.class); 725 } 726 727 /** 728 * Inserts a specific repetition of AL1 (Patient Allergy Information) 729 * @see AbstractGroup#insertRepetition(Structure, int) 730 */ 731 public void insertAL1(AL1 structure, int rep) throws HL7Exception { 732 super.insertRepetition("AL1", structure, rep); 733 } 734 735 736 /** 737 * Inserts a specific repetition of AL1 (Patient Allergy Information) 738 * @see AbstractGroup#insertRepetition(Structure, int) 739 */ 740 public AL1 insertAL1(int rep) throws HL7Exception { 741 return (AL1)super.insertRepetition("AL1", rep); 742 } 743 744 745 /** 746 * Removes a specific repetition of AL1 (Patient Allergy Information) 747 * @see AbstractGroup#removeRepetition(String, int) 748 */ 749 public AL1 removeAL1(int rep) throws HL7Exception { 750 return (AL1)super.removeRepetition("AL1", rep); 751 } 752 753 754 755 /** 756 * Returns 757 * the first repetition of 758 * DG1 (Diagnosis) - creates it if necessary 759 */ 760 public DG1 getDG1() { 761 DG1 retVal = getTyped("DG1", DG1.class); 762 return retVal; 763 } 764 765 766 /** 767 * Returns a specific repetition of 768 * DG1 (Diagnosis) - creates it if necessary 769 * 770 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 771 * @throws HL7Exception if the repetition requested is more than one 772 * greater than the number of existing repetitions. 773 */ 774 public DG1 getDG1(int rep) { 775 DG1 retVal = getTyped("DG1", rep, DG1.class); 776 return retVal; 777 } 778 779 /** 780 * Returns the number of existing repetitions of DG1 781 */ 782 public int getDG1Reps() { 783 return getReps("DG1"); 784 } 785 786 /** 787 * <p> 788 * Returns a non-modifiable List containing all current existing repetitions of DG1. 789 * <p> 790 * <p> 791 * Note that unlike {@link #getDG1()}, this method will not create any reps 792 * if none are already present, so an empty list may be returned. 793 * </p> 794 */ 795 public java.util.List<DG1> getDG1All() throws HL7Exception { 796 return getAllAsList("DG1", DG1.class); 797 } 798 799 /** 800 * Inserts a specific repetition of DG1 (Diagnosis) 801 * @see AbstractGroup#insertRepetition(Structure, int) 802 */ 803 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 804 super.insertRepetition("DG1", structure, rep); 805 } 806 807 808 /** 809 * Inserts a specific repetition of DG1 (Diagnosis) 810 * @see AbstractGroup#insertRepetition(Structure, int) 811 */ 812 public DG1 insertDG1(int rep) throws HL7Exception { 813 return (DG1)super.insertRepetition("DG1", rep); 814 } 815 816 817 /** 818 * Removes a specific repetition of DG1 (Diagnosis) 819 * @see AbstractGroup#removeRepetition(String, int) 820 */ 821 public DG1 removeDG1(int rep) throws HL7Exception { 822 return (DG1)super.removeRepetition("DG1", rep); 823 } 824 825 826 827 /** 828 * Returns 829 * DRG (Diagnosis Related Group) - creates it if necessary 830 */ 831 public DRG getDRG() { 832 DRG retVal = getTyped("DRG", DRG.class); 833 return retVal; 834 } 835 836 837 838 839 /** 840 * Returns 841 * the first repetition of 842 * PROCEDURE (a Group object) - creates it if necessary 843 */ 844 public ADR_A19_PROCEDURE getPROCEDURE() { 845 ADR_A19_PROCEDURE retVal = getTyped("PROCEDURE", ADR_A19_PROCEDURE.class); 846 return retVal; 847 } 848 849 850 /** 851 * Returns a specific repetition of 852 * PROCEDURE (a Group object) - creates it if necessary 853 * 854 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 855 * @throws HL7Exception if the repetition requested is more than one 856 * greater than the number of existing repetitions. 857 */ 858 public ADR_A19_PROCEDURE getPROCEDURE(int rep) { 859 ADR_A19_PROCEDURE retVal = getTyped("PROCEDURE", rep, ADR_A19_PROCEDURE.class); 860 return retVal; 861 } 862 863 /** 864 * Returns the number of existing repetitions of PROCEDURE 865 */ 866 public int getPROCEDUREReps() { 867 return getReps("PROCEDURE"); 868 } 869 870 /** 871 * <p> 872 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE. 873 * <p> 874 * <p> 875 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps 876 * if none are already present, so an empty list may be returned. 877 * </p> 878 */ 879 public java.util.List<ADR_A19_PROCEDURE> getPROCEDUREAll() throws HL7Exception { 880 return getAllAsList("PROCEDURE", ADR_A19_PROCEDURE.class); 881 } 882 883 /** 884 * Inserts a specific repetition of PROCEDURE (a Group object) 885 * @see AbstractGroup#insertRepetition(Structure, int) 886 */ 887 public void insertPROCEDURE(ADR_A19_PROCEDURE structure, int rep) throws HL7Exception { 888 super.insertRepetition("PROCEDURE", structure, rep); 889 } 890 891 892 /** 893 * Inserts a specific repetition of PROCEDURE (a Group object) 894 * @see AbstractGroup#insertRepetition(Structure, int) 895 */ 896 public ADR_A19_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception { 897 return (ADR_A19_PROCEDURE)super.insertRepetition("PROCEDURE", rep); 898 } 899 900 901 /** 902 * Removes a specific repetition of PROCEDURE (a Group object) 903 * @see AbstractGroup#removeRepetition(String, int) 904 */ 905 public ADR_A19_PROCEDURE removePROCEDURE(int rep) throws HL7Exception { 906 return (ADR_A19_PROCEDURE)super.removeRepetition("PROCEDURE", rep); 907 } 908 909 910 911 /** 912 * Returns 913 * the first repetition of 914 * GT1 (Guarantor) - creates it if necessary 915 */ 916 public GT1 getGT1() { 917 GT1 retVal = getTyped("GT1", GT1.class); 918 return retVal; 919 } 920 921 922 /** 923 * Returns a specific repetition of 924 * GT1 (Guarantor) - creates it if necessary 925 * 926 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 927 * @throws HL7Exception if the repetition requested is more than one 928 * greater than the number of existing repetitions. 929 */ 930 public GT1 getGT1(int rep) { 931 GT1 retVal = getTyped("GT1", rep, GT1.class); 932 return retVal; 933 } 934 935 /** 936 * Returns the number of existing repetitions of GT1 937 */ 938 public int getGT1Reps() { 939 return getReps("GT1"); 940 } 941 942 /** 943 * <p> 944 * Returns a non-modifiable List containing all current existing repetitions of GT1. 945 * <p> 946 * <p> 947 * Note that unlike {@link #getGT1()}, this method will not create any reps 948 * if none are already present, so an empty list may be returned. 949 * </p> 950 */ 951 public java.util.List<GT1> getGT1All() throws HL7Exception { 952 return getAllAsList("GT1", GT1.class); 953 } 954 955 /** 956 * Inserts a specific repetition of GT1 (Guarantor) 957 * @see AbstractGroup#insertRepetition(Structure, int) 958 */ 959 public void insertGT1(GT1 structure, int rep) throws HL7Exception { 960 super.insertRepetition("GT1", structure, rep); 961 } 962 963 964 /** 965 * Inserts a specific repetition of GT1 (Guarantor) 966 * @see AbstractGroup#insertRepetition(Structure, int) 967 */ 968 public GT1 insertGT1(int rep) throws HL7Exception { 969 return (GT1)super.insertRepetition("GT1", rep); 970 } 971 972 973 /** 974 * Removes a specific repetition of GT1 (Guarantor) 975 * @see AbstractGroup#removeRepetition(String, int) 976 */ 977 public GT1 removeGT1(int rep) throws HL7Exception { 978 return (GT1)super.removeRepetition("GT1", rep); 979 } 980 981 982 983 /** 984 * Returns 985 * the first repetition of 986 * INSURANCE (a Group object) - creates it if necessary 987 */ 988 public ADR_A19_INSURANCE getINSURANCE() { 989 ADR_A19_INSURANCE retVal = getTyped("INSURANCE", ADR_A19_INSURANCE.class); 990 return retVal; 991 } 992 993 994 /** 995 * Returns a specific repetition of 996 * INSURANCE (a Group object) - creates it if necessary 997 * 998 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 999 * @throws HL7Exception if the repetition requested is more than one 1000 * greater than the number of existing repetitions. 1001 */ 1002 public ADR_A19_INSURANCE getINSURANCE(int rep) { 1003 ADR_A19_INSURANCE retVal = getTyped("INSURANCE", rep, ADR_A19_INSURANCE.class); 1004 return retVal; 1005 } 1006 1007 /** 1008 * Returns the number of existing repetitions of INSURANCE 1009 */ 1010 public int getINSURANCEReps() { 1011 return getReps("INSURANCE"); 1012 } 1013 1014 /** 1015 * <p> 1016 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE. 1017 * <p> 1018 * <p> 1019 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps 1020 * if none are already present, so an empty list may be returned. 1021 * </p> 1022 */ 1023 public java.util.List<ADR_A19_INSURANCE> getINSURANCEAll() throws HL7Exception { 1024 return getAllAsList("INSURANCE", ADR_A19_INSURANCE.class); 1025 } 1026 1027 /** 1028 * Inserts a specific repetition of INSURANCE (a Group object) 1029 * @see AbstractGroup#insertRepetition(Structure, int) 1030 */ 1031 public void insertINSURANCE(ADR_A19_INSURANCE structure, int rep) throws HL7Exception { 1032 super.insertRepetition("INSURANCE", structure, rep); 1033 } 1034 1035 1036 /** 1037 * Inserts a specific repetition of INSURANCE (a Group object) 1038 * @see AbstractGroup#insertRepetition(Structure, int) 1039 */ 1040 public ADR_A19_INSURANCE insertINSURANCE(int rep) throws HL7Exception { 1041 return (ADR_A19_INSURANCE)super.insertRepetition("INSURANCE", rep); 1042 } 1043 1044 1045 /** 1046 * Removes a specific repetition of INSURANCE (a Group object) 1047 * @see AbstractGroup#removeRepetition(String, int) 1048 */ 1049 public ADR_A19_INSURANCE removeINSURANCE(int rep) throws HL7Exception { 1050 return (ADR_A19_INSURANCE)super.removeRepetition("INSURANCE", rep); 1051 } 1052 1053 1054 1055 /** 1056 * Returns 1057 * ACC (Accident) - creates it if necessary 1058 */ 1059 public ACC getACC() { 1060 ACC retVal = getTyped("ACC", ACC.class); 1061 return retVal; 1062 } 1063 1064 1065 1066 1067 /** 1068 * Returns 1069 * UB1 (UB82) - creates it if necessary 1070 */ 1071 public UB1 getUB1() { 1072 UB1 retVal = getTyped("UB1", UB1.class); 1073 return retVal; 1074 } 1075 1076 1077 1078 1079 /** 1080 * Returns 1081 * UB2 (UB92 Data) - creates it if necessary 1082 */ 1083 public UB2 getUB2() { 1084 UB2 retVal = getTyped("UB2", UB2.class); 1085 return retVal; 1086 } 1087 1088 1089 1090 1091 } 1092