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.v281.group; 35 36 import ca.uhn.hl7v2.model.v281.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 OMQ_O42_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: OBX (Observation/Result) <b> </b></li> 51 * <li>4: PRT (Participation Information) <b>optional repeating </b></li> 52 * <li>5: TXA (Transcription Document Header) <b> </b></li> 53 * <li>6: CTD (Contact Data) <b>optional </b></li> 54 * <li>7: DG1 (Diagnosis) <b>optional repeating </b></li> 55 * <li>8: OMQ_O42_ORDER_DOCUMENT (a Group object) <b>optional repeating </b></li> 56 * <li>9: OMQ_O42_OBSERVATION (a Group object) <b>optional repeating </b></li> 57 * <li>10: OMQ_O42_PRIOR_RESULT (a Group object) <b>optional repeating </b></li> 58 * <li>11: FT1 (Financial Transaction) <b>optional repeating </b></li> 59 * <li>12: CTI (Clinical Trial Identification) <b>optional repeating </b></li> 60 * <li>13: BLG (Billing) <b>optional </b></li> 61 * </ul> 62 */ 63 //@SuppressWarnings("unused") 64 public class OMQ_O42_ORDER extends AbstractGroup { 65 66 /** 67 * Creates a new OMQ_O42_ORDER group 68 */ 69 public OMQ_O42_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(OBX.class, true, false, false); 79 this.add(PRT.class, false, true, false); 80 this.add(TXA.class, true, false, false); 81 this.add(CTD.class, false, false, false); 82 this.add(DG1.class, false, true, false); 83 this.add(OMQ_O42_ORDER_DOCUMENT.class, false, true, false); 84 this.add(OMQ_O42_OBSERVATION.class, false, true, false); 85 this.add(OMQ_O42_PRIOR_RESULT.class, false, true, false); 86 this.add(FT1.class, false, true, false); 87 this.add(CTI.class, false, true, false); 88 this.add(BLG.class, false, false, false); 89 } catch(HL7Exception e) { 90 log.error("Unexpected error creating OMQ_O42_ORDER - this is probably a bug in the source code generator.", e); 91 } 92 } 93 94 /** 95 * Returns "2.8.1" 96 */ 97 public String getVersion() { 98 return "2.8.1"; 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 * OBX (Observation/Result) - creates it if necessary 190 */ 191 public OBX getOBX() { 192 OBX retVal = getTyped("OBX", OBX.class); 193 return retVal; 194 } 195 196 197 198 199 /** 200 * Returns 201 * the first repetition of 202 * PRT2 (Participation Information) - creates it if necessary 203 */ 204 public PRT getPRT2() { 205 PRT retVal = getTyped("PRT2", PRT.class); 206 return retVal; 207 } 208 209 210 /** 211 * Returns a specific repetition of 212 * PRT (Participation Information) - creates it if necessary 213 * 214 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0) 215 * @throws HL7Exception if the repetition requested is more than one 216 * greater than the number of existing repetitions. 217 */ 218 public PRT getPRT2(int rep) { 219 PRT retVal = getTyped("PRT2", rep, PRT.class); 220 return retVal; 221 } 222 223 /** 224 * Returns the number of existing repetitions of PRT2 225 */ 226 public int getPRT2Reps() { 227 return getReps("PRT2"); 228 } 229 230 /** 231 * <p> 232 * Returns a non-modifiable List containing all current existing repetitions of PRT2. 233 * <p> 234 * <p> 235 * Note that unlike {@link #getPRT2()}, this method will not create any reps 236 * if none are already present, so an empty list may be returned. 237 * </p> 238 */ 239 public java.util.List<PRT> getPRT2All() throws HL7Exception { 240 return getAllAsList("PRT2", PRT.class); 241 } 242 243 /** 244 * Inserts a specific repetition of PRT2 (Participation Information) 245 * @see AbstractGroup#insertRepetition(Structure, int) 246 */ 247 public void insertPRT2(PRT structure, int rep) throws HL7Exception { 248 super.insertRepetition("PRT2", structure, rep); 249 } 250 251 252 /** 253 * Inserts a specific repetition of PRT2 (Participation Information) 254 * @see AbstractGroup#insertRepetition(Structure, int) 255 */ 256 public PRT insertPRT2(int rep) throws HL7Exception { 257 return (PRT)super.insertRepetition("PRT2", rep); 258 } 259 260 261 /** 262 * Removes a specific repetition of PRT2 (Participation Information) 263 * @see AbstractGroup#removeRepetition(String, int) 264 */ 265 public PRT removePRT2(int rep) throws HL7Exception { 266 return (PRT)super.removeRepetition("PRT2", rep); 267 } 268 269 270 271 /** 272 * Returns 273 * TXA (Transcription Document Header) - creates it if necessary 274 */ 275 public TXA getTXA() { 276 TXA retVal = getTyped("TXA", TXA.class); 277 return retVal; 278 } 279 280 281 282 283 /** 284 * Returns 285 * CTD (Contact Data) - creates it if necessary 286 */ 287 public CTD getCTD() { 288 CTD retVal = getTyped("CTD", CTD.class); 289 return retVal; 290 } 291 292 293 294 295 /** 296 * Returns 297 * the first repetition of 298 * DG1 (Diagnosis) - creates it if necessary 299 */ 300 public DG1 getDG1() { 301 DG1 retVal = getTyped("DG1", DG1.class); 302 return retVal; 303 } 304 305 306 /** 307 * Returns a specific repetition of 308 * DG1 (Diagnosis) - 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 DG1 getDG1(int rep) { 315 DG1 retVal = getTyped("DG1", rep, DG1.class); 316 return retVal; 317 } 318 319 /** 320 * Returns the number of existing repetitions of DG1 321 */ 322 public int getDG1Reps() { 323 return getReps("DG1"); 324 } 325 326 /** 327 * <p> 328 * Returns a non-modifiable List containing all current existing repetitions of DG1. 329 * <p> 330 * <p> 331 * Note that unlike {@link #getDG1()}, 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<DG1> getDG1All() throws HL7Exception { 336 return getAllAsList("DG1", DG1.class); 337 } 338 339 /** 340 * Inserts a specific repetition of DG1 (Diagnosis) 341 * @see AbstractGroup#insertRepetition(Structure, int) 342 */ 343 public void insertDG1(DG1 structure, int rep) throws HL7Exception { 344 super.insertRepetition("DG1", structure, rep); 345 } 346 347 348 /** 349 * Inserts a specific repetition of DG1 (Diagnosis) 350 * @see AbstractGroup#insertRepetition(Structure, int) 351 */ 352 public DG1 insertDG1(int rep) throws HL7Exception { 353 return (DG1)super.insertRepetition("DG1", rep); 354 } 355 356 357 /** 358 * Removes a specific repetition of DG1 (Diagnosis) 359 * @see AbstractGroup#removeRepetition(String, int) 360 */ 361 public DG1 removeDG1(int rep) throws HL7Exception { 362 return (DG1)super.removeRepetition("DG1", rep); 363 } 364 365 366 367 /** 368 * Returns 369 * the first repetition of 370 * ORDER_DOCUMENT (a Group object) - creates it if necessary 371 */ 372 public OMQ_O42_ORDER_DOCUMENT getORDER_DOCUMENT() { 373 OMQ_O42_ORDER_DOCUMENT retVal = getTyped("ORDER_DOCUMENT", OMQ_O42_ORDER_DOCUMENT.class); 374 return retVal; 375 } 376 377 378 /** 379 * Returns a specific repetition of 380 * ORDER_DOCUMENT (a Group object) - 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 OMQ_O42_ORDER_DOCUMENT getORDER_DOCUMENT(int rep) { 387 OMQ_O42_ORDER_DOCUMENT retVal = getTyped("ORDER_DOCUMENT", rep, OMQ_O42_ORDER_DOCUMENT.class); 388 return retVal; 389 } 390 391 /** 392 * Returns the number of existing repetitions of ORDER_DOCUMENT 393 */ 394 public int getORDER_DOCUMENTReps() { 395 return getReps("ORDER_DOCUMENT"); 396 } 397 398 /** 399 * <p> 400 * Returns a non-modifiable List containing all current existing repetitions of ORDER_DOCUMENT. 401 * <p> 402 * <p> 403 * Note that unlike {@link #getORDER_DOCUMENT()}, 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<OMQ_O42_ORDER_DOCUMENT> getORDER_DOCUMENTAll() throws HL7Exception { 408 return getAllAsList("ORDER_DOCUMENT", OMQ_O42_ORDER_DOCUMENT.class); 409 } 410 411 /** 412 * Inserts a specific repetition of ORDER_DOCUMENT (a Group object) 413 * @see AbstractGroup#insertRepetition(Structure, int) 414 */ 415 public void insertORDER_DOCUMENT(OMQ_O42_ORDER_DOCUMENT structure, int rep) throws HL7Exception { 416 super.insertRepetition("ORDER_DOCUMENT", structure, rep); 417 } 418 419 420 /** 421 * Inserts a specific repetition of ORDER_DOCUMENT (a Group object) 422 * @see AbstractGroup#insertRepetition(Structure, int) 423 */ 424 public OMQ_O42_ORDER_DOCUMENT insertORDER_DOCUMENT(int rep) throws HL7Exception { 425 return (OMQ_O42_ORDER_DOCUMENT)super.insertRepetition("ORDER_DOCUMENT", rep); 426 } 427 428 429 /** 430 * Removes a specific repetition of ORDER_DOCUMENT (a Group object) 431 * @see AbstractGroup#removeRepetition(String, int) 432 */ 433 public OMQ_O42_ORDER_DOCUMENT removeORDER_DOCUMENT(int rep) throws HL7Exception { 434 return (OMQ_O42_ORDER_DOCUMENT)super.removeRepetition("ORDER_DOCUMENT", rep); 435 } 436 437 438 439 /** 440 * Returns 441 * the first repetition of 442 * OBSERVATION (a Group object) - creates it if necessary 443 */ 444 public OMQ_O42_OBSERVATION getOBSERVATION() { 445 OMQ_O42_OBSERVATION retVal = getTyped("OBSERVATION", OMQ_O42_OBSERVATION.class); 446 return retVal; 447 } 448 449 450 /** 451 * Returns a specific repetition of 452 * OBSERVATION (a Group object) - 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 OMQ_O42_OBSERVATION getOBSERVATION(int rep) { 459 OMQ_O42_OBSERVATION retVal = getTyped("OBSERVATION", rep, OMQ_O42_OBSERVATION.class); 460 return retVal; 461 } 462 463 /** 464 * Returns the number of existing repetitions of OBSERVATION 465 */ 466 public int getOBSERVATIONReps() { 467 return getReps("OBSERVATION"); 468 } 469 470 /** 471 * <p> 472 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION. 473 * <p> 474 * <p> 475 * Note that unlike {@link #getOBSERVATION()}, 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<OMQ_O42_OBSERVATION> getOBSERVATIONAll() throws HL7Exception { 480 return getAllAsList("OBSERVATION", OMQ_O42_OBSERVATION.class); 481 } 482 483 /** 484 * Inserts a specific repetition of OBSERVATION (a Group object) 485 * @see AbstractGroup#insertRepetition(Structure, int) 486 */ 487 public void insertOBSERVATION(OMQ_O42_OBSERVATION structure, int rep) throws HL7Exception { 488 super.insertRepetition("OBSERVATION", structure, rep); 489 } 490 491 492 /** 493 * Inserts a specific repetition of OBSERVATION (a Group object) 494 * @see AbstractGroup#insertRepetition(Structure, int) 495 */ 496 public OMQ_O42_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception { 497 return (OMQ_O42_OBSERVATION)super.insertRepetition("OBSERVATION", rep); 498 } 499 500 501 /** 502 * Removes a specific repetition of OBSERVATION (a Group object) 503 * @see AbstractGroup#removeRepetition(String, int) 504 */ 505 public OMQ_O42_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception { 506 return (OMQ_O42_OBSERVATION)super.removeRepetition("OBSERVATION", rep); 507 } 508 509 510 511 /** 512 * Returns 513 * the first repetition of 514 * PRIOR_RESULT (a Group object) - creates it if necessary 515 */ 516 public OMQ_O42_PRIOR_RESULT getPRIOR_RESULT() { 517 OMQ_O42_PRIOR_RESULT retVal = getTyped("PRIOR_RESULT", OMQ_O42_PRIOR_RESULT.class); 518 return retVal; 519 } 520 521 522 /** 523 * Returns a specific repetition of 524 * PRIOR_RESULT (a Group object) - 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 OMQ_O42_PRIOR_RESULT getPRIOR_RESULT(int rep) { 531 OMQ_O42_PRIOR_RESULT retVal = getTyped("PRIOR_RESULT", rep, OMQ_O42_PRIOR_RESULT.class); 532 return retVal; 533 } 534 535 /** 536 * Returns the number of existing repetitions of PRIOR_RESULT 537 */ 538 public int getPRIOR_RESULTReps() { 539 return getReps("PRIOR_RESULT"); 540 } 541 542 /** 543 * <p> 544 * Returns a non-modifiable List containing all current existing repetitions of PRIOR_RESULT. 545 * <p> 546 * <p> 547 * Note that unlike {@link #getPRIOR_RESULT()}, 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<OMQ_O42_PRIOR_RESULT> getPRIOR_RESULTAll() throws HL7Exception { 552 return getAllAsList("PRIOR_RESULT", OMQ_O42_PRIOR_RESULT.class); 553 } 554 555 /** 556 * Inserts a specific repetition of PRIOR_RESULT (a Group object) 557 * @see AbstractGroup#insertRepetition(Structure, int) 558 */ 559 public void insertPRIOR_RESULT(OMQ_O42_PRIOR_RESULT structure, int rep) throws HL7Exception { 560 super.insertRepetition("PRIOR_RESULT", structure, rep); 561 } 562 563 564 /** 565 * Inserts a specific repetition of PRIOR_RESULT (a Group object) 566 * @see AbstractGroup#insertRepetition(Structure, int) 567 */ 568 public OMQ_O42_PRIOR_RESULT insertPRIOR_RESULT(int rep) throws HL7Exception { 569 return (OMQ_O42_PRIOR_RESULT)super.insertRepetition("PRIOR_RESULT", rep); 570 } 571 572 573 /** 574 * Removes a specific repetition of PRIOR_RESULT (a Group object) 575 * @see AbstractGroup#removeRepetition(String, int) 576 */ 577 public OMQ_O42_PRIOR_RESULT removePRIOR_RESULT(int rep) throws HL7Exception { 578 return (OMQ_O42_PRIOR_RESULT)super.removeRepetition("PRIOR_RESULT", rep); 579 } 580 581 582 583 /** 584 * Returns 585 * the first repetition of 586 * FT1 (Financial Transaction) - creates it if necessary 587 */ 588 public FT1 getFT1() { 589 FT1 retVal = getTyped("FT1", FT1.class); 590 return retVal; 591 } 592 593 594 /** 595 * Returns a specific repetition of 596 * FT1 (Financial Transaction) - 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 FT1 getFT1(int rep) { 603 FT1 retVal = getTyped("FT1", rep, FT1.class); 604 return retVal; 605 } 606 607 /** 608 * Returns the number of existing repetitions of FT1 609 */ 610 public int getFT1Reps() { 611 return getReps("FT1"); 612 } 613 614 /** 615 * <p> 616 * Returns a non-modifiable List containing all current existing repetitions of FT1. 617 * <p> 618 * <p> 619 * Note that unlike {@link #getFT1()}, 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<FT1> getFT1All() throws HL7Exception { 624 return getAllAsList("FT1", FT1.class); 625 } 626 627 /** 628 * Inserts a specific repetition of FT1 (Financial Transaction) 629 * @see AbstractGroup#insertRepetition(Structure, int) 630 */ 631 public void insertFT1(FT1 structure, int rep) throws HL7Exception { 632 super.insertRepetition("FT1", structure, rep); 633 } 634 635 636 /** 637 * Inserts a specific repetition of FT1 (Financial Transaction) 638 * @see AbstractGroup#insertRepetition(Structure, int) 639 */ 640 public FT1 insertFT1(int rep) throws HL7Exception { 641 return (FT1)super.insertRepetition("FT1", rep); 642 } 643 644 645 /** 646 * Removes a specific repetition of FT1 (Financial Transaction) 647 * @see AbstractGroup#removeRepetition(String, int) 648 */ 649 public FT1 removeFT1(int rep) throws HL7Exception { 650 return (FT1)super.removeRepetition("FT1", rep); 651 } 652 653 654 655 /** 656 * Returns 657 * the first repetition of 658 * CTI (Clinical Trial Identification) - creates it if necessary 659 */ 660 public CTI getCTI() { 661 CTI retVal = getTyped("CTI", CTI.class); 662 return retVal; 663 } 664 665 666 /** 667 * Returns a specific repetition of 668 * CTI (Clinical Trial Identification) - 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 CTI getCTI(int rep) { 675 CTI retVal = getTyped("CTI", rep, CTI.class); 676 return retVal; 677 } 678 679 /** 680 * Returns the number of existing repetitions of CTI 681 */ 682 public int getCTIReps() { 683 return getReps("CTI"); 684 } 685 686 /** 687 * <p> 688 * Returns a non-modifiable List containing all current existing repetitions of CTI. 689 * <p> 690 * <p> 691 * Note that unlike {@link #getCTI()}, 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<CTI> getCTIAll() throws HL7Exception { 696 return getAllAsList("CTI", CTI.class); 697 } 698 699 /** 700 * Inserts a specific repetition of CTI (Clinical Trial Identification) 701 * @see AbstractGroup#insertRepetition(Structure, int) 702 */ 703 public void insertCTI(CTI structure, int rep) throws HL7Exception { 704 super.insertRepetition("CTI", structure, rep); 705 } 706 707 708 /** 709 * Inserts a specific repetition of CTI (Clinical Trial Identification) 710 * @see AbstractGroup#insertRepetition(Structure, int) 711 */ 712 public CTI insertCTI(int rep) throws HL7Exception { 713 return (CTI)super.insertRepetition("CTI", rep); 714 } 715 716 717 /** 718 * Removes a specific repetition of CTI (Clinical Trial Identification) 719 * @see AbstractGroup#removeRepetition(String, int) 720 */ 721 public CTI removeCTI(int rep) throws HL7Exception { 722 return (CTI)super.removeRepetition("CTI", rep); 723 } 724 725 726 727 /** 728 * Returns 729 * BLG (Billing) - creates it if necessary 730 */ 731 public BLG getBLG() { 732 BLG retVal = getTyped("BLG", BLG.class); 733 return retVal; 734 } 735 736 737 738 739 } 740