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.v28.group; 35 36 import ca.uhn.hl7v2.model.v28.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 RDS_O13_ORDER 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: ORC (Common Order) <b> </b></li> 49 * <li>2: PRT (Participation Information) <b>optional repeating </b></li> 50 * <li>3: RDS_O13_TIMING (a Group object) <b>optional repeating </b></li> 51 * <li>4: RDS_O13_ORDER_DETAIL (a Group object) <b>optional </b></li> 52 * <li>5: RDS_O13_ENCODING (a Group object) <b>optional </b></li> 53 * <li>6: RXD (Pharmacy/Treatment Dispense) <b> </b></li> 54 * <li>7: PRT (Participation Information) <b>optional repeating </b></li> 55 * <li>8: NTE (Notes and Comments) <b>optional repeating </b></li> 56 * <li>9: RXR (Pharmacy/Treatment Route) <b> repeating </b></li> 57 * <li>10: RXC (Pharmacy/Treatment Component Order) <b>optional repeating </b></li> 58 * <li>11: CDO (Cumulative Dosage) <b>optional repeating </b></li> 59 * <li>12: RDS_O13_OBSERVATION (a Group object) <b>optional repeating </b></li> 60 * <li>13: FT1 (Financial Transaction) <b>optional repeating </b></li> 61 * </ul> 62 */ 63 //@SuppressWarnings("unused") 64 public class RDS_O13_ORDER extends AbstractGroup { 65 66 /** 67 * Creates a new RDS_O13_ORDER group 68 */ 69 public RDS_O13_ORDER(Group parent, ModelClassFactory factory) { 70 super(parent, factory); 71 init(factory); 72 } 73 74 private void init(ModelClassFactory factory) { 75 try { 76 this.add(ORC.class, true, false, false); 77 this.add(PRT.class, false, true, false); 78 this.add(RDS_O13_TIMING.class, false, true, false); 79 this.add(RDS_O13_ORDER_DETAIL.class, false, false, false); 80 this.add(RDS_O13_ENCODING.class, false, false, false); 81 this.add(RXD.class, true, false, false); 82 this.add(PRT.class, false, true, false); 83 this.add(NTE.class, false, true, false); 84 this.add(RXR.class, true, true, false); 85 this.add(RXC.class, false, true, false); 86 this.add(CDO.class, false, true, false); 87 this.add(RDS_O13_OBSERVATION.class, false, true, false); 88 this.add(FT1.class, false, true, false); 89 } catch(HL7Exception e) { 90 log.error("Unexpected error creating RDS_O13_ORDER - this is probably a bug in the source code generator.", e); 91 } 92 } 93 94 /** 95 * Returns "2.8" 96 */ 97 public String getVersion() { 98 return "2.8"; 99 } 100 101 102 103 /** 104 * Returns 105 * ORC (Common Order) - creates it if necessary 106 */ 107 public ORC getORC() { 108 ORC retVal = getTyped("ORC", ORC.class); 109 return retVal; 110 } 111 112 113 114 115 /** 116 * Returns 117 * the first repetition of 118 * PRT (Participation Information) - creates it if necessary 119 */ 120 public PRT getPRT() { 121 PRT retVal = getTyped("PRT", PRT.class); 122 return retVal; 123 } 124 125 126 /** 127 * Returns a specific repetition of 128 * PRT (Participation Information) - creates it if necessary 129 * 130 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 131 * @throws HL7Exception if the repetition requested is more than one 132 * greater than the number of existing repetitions. 133 */ 134 public PRT getPRT(int rep) { 135 PRT retVal = getTyped("PRT", rep, PRT.class); 136 return retVal; 137 } 138 139 /** 140 * Returns the number of existing repetitions of PRT 141 */ 142 public int getPRTReps() { 143 return getReps("PRT"); 144 } 145 146 /** 147 * <p> 148 * Returns a non-modifiable List containing all current existing repetitions of PRT. 149 * <p> 150 * <p> 151 * Note that unlike {@link #getPRT()}, this method will not create any reps 152 * if none are already present, so an empty list may be returned. 153 * </p> 154 */ 155 public java.util.List<PRT> getPRTAll() throws HL7Exception { 156 return getAllAsList("PRT", PRT.class); 157 } 158 159 /** 160 * Inserts a specific repetition of PRT (Participation Information) 161 * @see AbstractGroup#insertRepetition(Structure, int) 162 */ 163 public void insertPRT(PRT structure, int rep) throws HL7Exception { 164 super.insertRepetition("PRT", structure, rep); 165 } 166 167 168 /** 169 * Inserts a specific repetition of PRT (Participation Information) 170 * @see AbstractGroup#insertRepetition(Structure, int) 171 */ 172 public PRT insertPRT(int rep) throws HL7Exception { 173 return (PRT)super.insertRepetition("PRT", rep); 174 } 175 176 177 /** 178 * Removes a specific repetition of PRT (Participation Information) 179 * @see AbstractGroup#removeRepetition(String, int) 180 */ 181 public PRT removePRT(int rep) throws HL7Exception { 182 return (PRT)super.removeRepetition("PRT", rep); 183 } 184 185 186 187 /** 188 * Returns 189 * the first repetition of 190 * TIMING (a Group object) - creates it if necessary 191 */ 192 public RDS_O13_TIMING getTIMING() { 193 RDS_O13_TIMING retVal = getTyped("TIMING", RDS_O13_TIMING.class); 194 return retVal; 195 } 196 197 198 /** 199 * Returns a specific repetition of 200 * TIMING (a Group object) - creates it if necessary 201 * 202 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 203 * @throws HL7Exception if the repetition requested is more than one 204 * greater than the number of existing repetitions. 205 */ 206 public RDS_O13_TIMING getTIMING(int rep) { 207 RDS_O13_TIMING retVal = getTyped("TIMING", rep, RDS_O13_TIMING.class); 208 return retVal; 209 } 210 211 /** 212 * Returns the number of existing repetitions of TIMING 213 */ 214 public int getTIMINGReps() { 215 return getReps("TIMING"); 216 } 217 218 /** 219 * <p> 220 * Returns a non-modifiable List containing all current existing repetitions of TIMING. 221 * <p> 222 * <p> 223 * Note that unlike {@link #getTIMING()}, this method will not create any reps 224 * if none are already present, so an empty list may be returned. 225 * </p> 226 */ 227 public java.util.List<RDS_O13_TIMING> getTIMINGAll() throws HL7Exception { 228 return getAllAsList("TIMING", RDS_O13_TIMING.class); 229 } 230 231 /** 232 * Inserts a specific repetition of TIMING (a Group object) 233 * @see AbstractGroup#insertRepetition(Structure, int) 234 */ 235 public void insertTIMING(RDS_O13_TIMING structure, int rep) throws HL7Exception { 236 super.insertRepetition("TIMING", structure, rep); 237 } 238 239 240 /** 241 * Inserts a specific repetition of TIMING (a Group object) 242 * @see AbstractGroup#insertRepetition(Structure, int) 243 */ 244 public RDS_O13_TIMING insertTIMING(int rep) throws HL7Exception { 245 return (RDS_O13_TIMING)super.insertRepetition("TIMING", rep); 246 } 247 248 249 /** 250 * Removes a specific repetition of TIMING (a Group object) 251 * @see AbstractGroup#removeRepetition(String, int) 252 */ 253 public RDS_O13_TIMING removeTIMING(int rep) throws HL7Exception { 254 return (RDS_O13_TIMING)super.removeRepetition("TIMING", rep); 255 } 256 257 258 259 /** 260 * Returns 261 * ORDER_DETAIL (a Group object) - creates it if necessary 262 */ 263 public RDS_O13_ORDER_DETAIL getORDER_DETAIL() { 264 RDS_O13_ORDER_DETAIL retVal = getTyped("ORDER_DETAIL", RDS_O13_ORDER_DETAIL.class); 265 return retVal; 266 } 267 268 269 270 271 /** 272 * Returns 273 * ENCODING (a Group object) - creates it if necessary 274 */ 275 public RDS_O13_ENCODING getENCODING() { 276 RDS_O13_ENCODING retVal = getTyped("ENCODING", RDS_O13_ENCODING.class); 277 return retVal; 278 } 279 280 281 282 283 /** 284 * Returns 285 * RXD (Pharmacy/Treatment Dispense) - creates it if necessary 286 */ 287 public RXD getRXD() { 288 RXD retVal = getTyped("RXD", RXD.class); 289 return retVal; 290 } 291 292 293 294 295 /** 296 * Returns 297 * the first repetition of 298 * PRT2 (Participation Information) - creates it if necessary 299 */ 300 public PRT getPRT2() { 301 PRT retVal = getTyped("PRT2", PRT.class); 302 return retVal; 303 } 304 305 306 /** 307 * Returns a specific repetition of 308 * PRT (Participation Information) - creates it if necessary 309 * 310 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 311 * @throws HL7Exception if the repetition requested is more than one 312 * greater than the number of existing repetitions. 313 */ 314 public PRT getPRT2(int rep) { 315 PRT retVal = getTyped("PRT2", rep, PRT.class); 316 return retVal; 317 } 318 319 /** 320 * Returns the number of existing repetitions of PRT2 321 */ 322 public int getPRT2Reps() { 323 return getReps("PRT2"); 324 } 325 326 /** 327 * <p> 328 * Returns a non-modifiable List containing all current existing repetitions of PRT2. 329 * <p> 330 * <p> 331 * Note that unlike {@link #getPRT2()}, this method will not create any reps 332 * if none are already present, so an empty list may be returned. 333 * </p> 334 */ 335 public java.util.List<PRT> getPRT2All() throws HL7Exception { 336 return getAllAsList("PRT2", PRT.class); 337 } 338 339 /** 340 * Inserts a specific repetition of PRT2 (Participation Information) 341 * @see AbstractGroup#insertRepetition(Structure, int) 342 */ 343 public void insertPRT2(PRT structure, int rep) throws HL7Exception { 344 super.insertRepetition("PRT2", structure, rep); 345 } 346 347 348 /** 349 * Inserts a specific repetition of PRT2 (Participation Information) 350 * @see AbstractGroup#insertRepetition(Structure, int) 351 */ 352 public PRT insertPRT2(int rep) throws HL7Exception { 353 return (PRT)super.insertRepetition("PRT2", rep); 354 } 355 356 357 /** 358 * Removes a specific repetition of PRT2 (Participation Information) 359 * @see AbstractGroup#removeRepetition(String, int) 360 */ 361 public PRT removePRT2(int rep) throws HL7Exception { 362 return (PRT)super.removeRepetition("PRT2", rep); 363 } 364 365 366 367 /** 368 * Returns 369 * the first repetition of 370 * NTE (Notes and Comments) - creates it if necessary 371 */ 372 public NTE getNTE() { 373 NTE retVal = getTyped("NTE", NTE.class); 374 return retVal; 375 } 376 377 378 /** 379 * Returns a specific repetition of 380 * NTE (Notes and Comments) - creates it if necessary 381 * 382 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 383 * @throws HL7Exception if the repetition requested is more than one 384 * greater than the number of existing repetitions. 385 */ 386 public NTE getNTE(int rep) { 387 NTE retVal = getTyped("NTE", rep, NTE.class); 388 return retVal; 389 } 390 391 /** 392 * Returns the number of existing repetitions of NTE 393 */ 394 public int getNTEReps() { 395 return getReps("NTE"); 396 } 397 398 /** 399 * <p> 400 * Returns a non-modifiable List containing all current existing repetitions of NTE. 401 * <p> 402 * <p> 403 * Note that unlike {@link #getNTE()}, this method will not create any reps 404 * if none are already present, so an empty list may be returned. 405 * </p> 406 */ 407 public java.util.List<NTE> getNTEAll() throws HL7Exception { 408 return getAllAsList("NTE", NTE.class); 409 } 410 411 /** 412 * Inserts a specific repetition of NTE (Notes and Comments) 413 * @see AbstractGroup#insertRepetition(Structure, int) 414 */ 415 public void insertNTE(NTE structure, int rep) throws HL7Exception { 416 super.insertRepetition("NTE", structure, rep); 417 } 418 419 420 /** 421 * Inserts a specific repetition of NTE (Notes and Comments) 422 * @see AbstractGroup#insertRepetition(Structure, int) 423 */ 424 public NTE insertNTE(int rep) throws HL7Exception { 425 return (NTE)super.insertRepetition("NTE", rep); 426 } 427 428 429 /** 430 * Removes a specific repetition of NTE (Notes and Comments) 431 * @see AbstractGroup#removeRepetition(String, int) 432 */ 433 public NTE removeNTE(int rep) throws HL7Exception { 434 return (NTE)super.removeRepetition("NTE", rep); 435 } 436 437 438 439 /** 440 * Returns 441 * the first repetition of 442 * RXR (Pharmacy/Treatment Route) - creates it if necessary 443 */ 444 public RXR getRXR() { 445 RXR retVal = getTyped("RXR", RXR.class); 446 return retVal; 447 } 448 449 450 /** 451 * Returns a specific repetition of 452 * RXR (Pharmacy/Treatment Route) - creates it if necessary 453 * 454 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 455 * @throws HL7Exception if the repetition requested is more than one 456 * greater than the number of existing repetitions. 457 */ 458 public RXR getRXR(int rep) { 459 RXR retVal = getTyped("RXR", rep, RXR.class); 460 return retVal; 461 } 462 463 /** 464 * Returns the number of existing repetitions of RXR 465 */ 466 public int getRXRReps() { 467 return getReps("RXR"); 468 } 469 470 /** 471 * <p> 472 * Returns a non-modifiable List containing all current existing repetitions of RXR. 473 * <p> 474 * <p> 475 * Note that unlike {@link #getRXR()}, this method will not create any reps 476 * if none are already present, so an empty list may be returned. 477 * </p> 478 */ 479 public java.util.List<RXR> getRXRAll() throws HL7Exception { 480 return getAllAsList("RXR", RXR.class); 481 } 482 483 /** 484 * Inserts a specific repetition of RXR (Pharmacy/Treatment Route) 485 * @see AbstractGroup#insertRepetition(Structure, int) 486 */ 487 public void insertRXR(RXR structure, int rep) throws HL7Exception { 488 super.insertRepetition("RXR", structure, rep); 489 } 490 491 492 /** 493 * Inserts a specific repetition of RXR (Pharmacy/Treatment Route) 494 * @see AbstractGroup#insertRepetition(Structure, int) 495 */ 496 public RXR insertRXR(int rep) throws HL7Exception { 497 return (RXR)super.insertRepetition("RXR", rep); 498 } 499 500 501 /** 502 * Removes a specific repetition of RXR (Pharmacy/Treatment Route) 503 * @see AbstractGroup#removeRepetition(String, int) 504 */ 505 public RXR removeRXR(int rep) throws HL7Exception { 506 return (RXR)super.removeRepetition("RXR", rep); 507 } 508 509 510 511 /** 512 * Returns 513 * the first repetition of 514 * RXC (Pharmacy/Treatment Component Order) - creates it if necessary 515 */ 516 public RXC getRXC() { 517 RXC retVal = getTyped("RXC", RXC.class); 518 return retVal; 519 } 520 521 522 /** 523 * Returns a specific repetition of 524 * RXC (Pharmacy/Treatment Component Order) - creates it if necessary 525 * 526 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 527 * @throws HL7Exception if the repetition requested is more than one 528 * greater than the number of existing repetitions. 529 */ 530 public RXC getRXC(int rep) { 531 RXC retVal = getTyped("RXC", rep, RXC.class); 532 return retVal; 533 } 534 535 /** 536 * Returns the number of existing repetitions of RXC 537 */ 538 public int getRXCReps() { 539 return getReps("RXC"); 540 } 541 542 /** 543 * <p> 544 * Returns a non-modifiable List containing all current existing repetitions of RXC. 545 * <p> 546 * <p> 547 * Note that unlike {@link #getRXC()}, this method will not create any reps 548 * if none are already present, so an empty list may be returned. 549 * </p> 550 */ 551 public java.util.List<RXC> getRXCAll() throws HL7Exception { 552 return getAllAsList("RXC", RXC.class); 553 } 554 555 /** 556 * Inserts a specific repetition of RXC (Pharmacy/Treatment Component Order) 557 * @see AbstractGroup#insertRepetition(Structure, int) 558 */ 559 public void insertRXC(RXC structure, int rep) throws HL7Exception { 560 super.insertRepetition("RXC", structure, rep); 561 } 562 563 564 /** 565 * Inserts a specific repetition of RXC (Pharmacy/Treatment Component Order) 566 * @see AbstractGroup#insertRepetition(Structure, int) 567 */ 568 public RXC insertRXC(int rep) throws HL7Exception { 569 return (RXC)super.insertRepetition("RXC", rep); 570 } 571 572 573 /** 574 * Removes a specific repetition of RXC (Pharmacy/Treatment Component Order) 575 * @see AbstractGroup#removeRepetition(String, int) 576 */ 577 public RXC removeRXC(int rep) throws HL7Exception { 578 return (RXC)super.removeRepetition("RXC", rep); 579 } 580 581 582 583 /** 584 * Returns 585 * the first repetition of 586 * CDO (Cumulative Dosage) - creates it if necessary 587 */ 588 public CDO getCDO() { 589 CDO retVal = getTyped("CDO", CDO.class); 590 return retVal; 591 } 592 593 594 /** 595 * Returns a specific repetition of 596 * CDO (Cumulative Dosage) - creates it if necessary 597 * 598 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 599 * @throws HL7Exception if the repetition requested is more than one 600 * greater than the number of existing repetitions. 601 */ 602 public CDO getCDO(int rep) { 603 CDO retVal = getTyped("CDO", rep, CDO.class); 604 return retVal; 605 } 606 607 /** 608 * Returns the number of existing repetitions of CDO 609 */ 610 public int getCDOReps() { 611 return getReps("CDO"); 612 } 613 614 /** 615 * <p> 616 * Returns a non-modifiable List containing all current existing repetitions of CDO. 617 * <p> 618 * <p> 619 * Note that unlike {@link #getCDO()}, this method will not create any reps 620 * if none are already present, so an empty list may be returned. 621 * </p> 622 */ 623 public java.util.List<CDO> getCDOAll() throws HL7Exception { 624 return getAllAsList("CDO", CDO.class); 625 } 626 627 /** 628 * Inserts a specific repetition of CDO (Cumulative Dosage) 629 * @see AbstractGroup#insertRepetition(Structure, int) 630 */ 631 public void insertCDO(CDO structure, int rep) throws HL7Exception { 632 super.insertRepetition("CDO", structure, rep); 633 } 634 635 636 /** 637 * Inserts a specific repetition of CDO (Cumulative Dosage) 638 * @see AbstractGroup#insertRepetition(Structure, int) 639 */ 640 public CDO insertCDO(int rep) throws HL7Exception { 641 return (CDO)super.insertRepetition("CDO", rep); 642 } 643 644 645 /** 646 * Removes a specific repetition of CDO (Cumulative Dosage) 647 * @see AbstractGroup#removeRepetition(String, int) 648 */ 649 public CDO removeCDO(int rep) throws HL7Exception { 650 return (CDO)super.removeRepetition("CDO", rep); 651 } 652 653 654 655 /** 656 * Returns 657 * the first repetition of 658 * OBSERVATION (a Group object) - creates it if necessary 659 */ 660 public RDS_O13_OBSERVATION getOBSERVATION() { 661 RDS_O13_OBSERVATION retVal = getTyped("OBSERVATION", RDS_O13_OBSERVATION.class); 662 return retVal; 663 } 664 665 666 /** 667 * Returns a specific repetition of 668 * OBSERVATION (a Group object) - creates it if necessary 669 * 670 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 671 * @throws HL7Exception if the repetition requested is more than one 672 * greater than the number of existing repetitions. 673 */ 674 public RDS_O13_OBSERVATION getOBSERVATION(int rep) { 675 RDS_O13_OBSERVATION retVal = getTyped("OBSERVATION", rep, RDS_O13_OBSERVATION.class); 676 return retVal; 677 } 678 679 /** 680 * Returns the number of existing repetitions of OBSERVATION 681 */ 682 public int getOBSERVATIONReps() { 683 return getReps("OBSERVATION"); 684 } 685 686 /** 687 * <p> 688 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION. 689 * <p> 690 * <p> 691 * Note that unlike {@link #getOBSERVATION()}, this method will not create any reps 692 * if none are already present, so an empty list may be returned. 693 * </p> 694 */ 695 public java.util.List<RDS_O13_OBSERVATION> getOBSERVATIONAll() throws HL7Exception { 696 return getAllAsList("OBSERVATION", RDS_O13_OBSERVATION.class); 697 } 698 699 /** 700 * Inserts a specific repetition of OBSERVATION (a Group object) 701 * @see AbstractGroup#insertRepetition(Structure, int) 702 */ 703 public void insertOBSERVATION(RDS_O13_OBSERVATION structure, int rep) throws HL7Exception { 704 super.insertRepetition("OBSERVATION", structure, rep); 705 } 706 707 708 /** 709 * Inserts a specific repetition of OBSERVATION (a Group object) 710 * @see AbstractGroup#insertRepetition(Structure, int) 711 */ 712 public RDS_O13_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception { 713 return (RDS_O13_OBSERVATION)super.insertRepetition("OBSERVATION", rep); 714 } 715 716 717 /** 718 * Removes a specific repetition of OBSERVATION (a Group object) 719 * @see AbstractGroup#removeRepetition(String, int) 720 */ 721 public RDS_O13_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception { 722 return (RDS_O13_OBSERVATION)super.removeRepetition("OBSERVATION", rep); 723 } 724 725 726 727 /** 728 * Returns 729 * the first repetition of 730 * FT1 (Financial Transaction) - creates it if necessary 731 */ 732 public FT1 getFT1() { 733 FT1 retVal = getTyped("FT1", FT1.class); 734 return retVal; 735 } 736 737 738 /** 739 * Returns a specific repetition of 740 * FT1 (Financial Transaction) - creates it if necessary 741 * 742 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 743 * @throws HL7Exception if the repetition requested is more than one 744 * greater than the number of existing repetitions. 745 */ 746 public FT1 getFT1(int rep) { 747 FT1 retVal = getTyped("FT1", rep, FT1.class); 748 return retVal; 749 } 750 751 /** 752 * Returns the number of existing repetitions of FT1 753 */ 754 public int getFT1Reps() { 755 return getReps("FT1"); 756 } 757 758 /** 759 * <p> 760 * Returns a non-modifiable List containing all current existing repetitions of FT1. 761 * <p> 762 * <p> 763 * Note that unlike {@link #getFT1()}, this method will not create any reps 764 * if none are already present, so an empty list may be returned. 765 * </p> 766 */ 767 public java.util.List<FT1> getFT1All() throws HL7Exception { 768 return getAllAsList("FT1", FT1.class); 769 } 770 771 /** 772 * Inserts a specific repetition of FT1 (Financial Transaction) 773 * @see AbstractGroup#insertRepetition(Structure, int) 774 */ 775 public void insertFT1(FT1 structure, int rep) throws HL7Exception { 776 super.insertRepetition("FT1", structure, rep); 777 } 778 779 780 /** 781 * Inserts a specific repetition of FT1 (Financial Transaction) 782 * @see AbstractGroup#insertRepetition(Structure, int) 783 */ 784 public FT1 insertFT1(int rep) throws HL7Exception { 785 return (FT1)super.insertRepetition("FT1", rep); 786 } 787 788 789 /** 790 * Removes a specific repetition of FT1 (Financial Transaction) 791 * @see AbstractGroup#removeRepetition(String, int) 792 */ 793 public FT1 removeFT1(int rep) throws HL7Exception { 794 return (FT1)super.removeRepetition("FT1", rep); 795 } 796 797 798 799 } 800