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.v231.segment; 035 036// import ca.uhn.hl7v2.model.v231.group.*; 037import ca.uhn.hl7v2.model.v231.datatype.*; 038import ca.uhn.hl7v2.HL7Exception; 039import ca.uhn.hl7v2.parser.ModelClassFactory; 040import ca.uhn.hl7v2.parser.DefaultModelClassFactory; 041import ca.uhn.hl7v2.model.AbstractMessage; 042import ca.uhn.hl7v2.model.Group; 043import ca.uhn.hl7v2.model.Type; 044import ca.uhn.hl7v2.model.AbstractSegment; 045import ca.uhn.hl7v2.model.Varies; 046 047 048/** 049 *<p>Represents an HL7 FT1 message segment (FT1 - financial transaction segment). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>FT1-1: Set ID - FT1 (SI) <b>optional </b> 053 * <li>FT1-2: Transaction ID (ST) <b>optional </b> 054 * <li>FT1-3: Transaction Batch ID (ST) <b>optional </b> 055 * <li>FT1-4: Transaction Date (TS) <b> </b> 056 * <li>FT1-5: Transaction Posting Date (TS) <b>optional </b> 057 * <li>FT1-6: Transaction Type (IS) <b> </b> 058 * <li>FT1-7: Transaction Code (CE) <b> </b> 059 * <li>FT1-8: Transaction Description (ST) <b>optional </b> 060 * <li>FT1-9: Transaction Description - Alt (ST) <b>optional </b> 061 * <li>FT1-10: Transaction Quantity (NM) <b>optional </b> 062 * <li>FT1-11: Transaction Amount - Extended (CP) <b>optional </b> 063 * <li>FT1-12: Transaction Amount - Unit (CP) <b>optional </b> 064 * <li>FT1-13: Department Code (CE) <b>optional </b> 065 * <li>FT1-14: Insurance Plan ID (CE) <b>optional </b> 066 * <li>FT1-15: Insurance Amount (CP) <b>optional </b> 067 * <li>FT1-16: Assigned Patient Location (PL) <b>optional </b> 068 * <li>FT1-17: Fee Schedule (IS) <b>optional </b> 069 * <li>FT1-18: Patient Type (IS) <b>optional </b> 070 * <li>FT1-19: Diagnosis Code - FT1 (CE) <b>optional repeating</b> 071 * <li>FT1-20: Performed By Code (XCN) <b>optional repeating</b> 072 * <li>FT1-21: Ordered By Code (XCN) <b>optional repeating</b> 073 * <li>FT1-22: Unit Cost (CP) <b>optional </b> 074 * <li>FT1-23: Filler Order Number (EI) <b>optional </b> 075 * <li>FT1-24: Entered By Code (XCN) <b>optional repeating</b> 076 * <li>FT1-25: Procedure Code (CE) <b>optional </b> 077 * <li>FT1-26: Procedure Code Modifier (CE) <b>optional repeating</b> 078 * </ul> 079 */ 080@SuppressWarnings("unused") 081public class FT1 extends AbstractSegment { 082 083 /** 084 * Creates a new FT1 segment 085 */ 086 public FT1(Group parent, ModelClassFactory factory) { 087 super(parent, factory); 088 init(factory); 089 } 090 091 private void init(ModelClassFactory factory) { 092 try { 093 this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - FT1"); 094 this.add(ST.class, false, 1, 12, new Object[]{ getMessage() }, "Transaction ID"); 095 this.add(ST.class, false, 1, 10, new Object[]{ getMessage() }, "Transaction Batch ID"); 096 this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Transaction Date"); 097 this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Transaction Posting Date"); 098 this.add(IS.class, true, 1, 8, new Object[]{ getMessage(), new Integer(17) }, "Transaction Type"); 099 this.add(CE.class, true, 1, 80, new Object[]{ getMessage() }, "Transaction Code"); 100 this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Transaction Description"); 101 this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Transaction Description - Alt"); 102 this.add(NM.class, false, 1, 6, new Object[]{ getMessage() }, "Transaction Quantity"); 103 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Transaction Amount - Extended"); 104 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Transaction Amount - Unit"); 105 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Department Code"); 106 this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Insurance Plan ID"); 107 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Insurance Amount"); 108 this.add(PL.class, false, 1, 80, new Object[]{ getMessage() }, "Assigned Patient Location"); 109 this.add(IS.class, false, 1, 1, new Object[]{ getMessage(), new Integer(24) }, "Fee Schedule"); 110 this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(18) }, "Patient Type"); 111 this.add(CE.class, false, 0, 60, new Object[]{ getMessage() }, "Diagnosis Code - FT1"); 112 this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Performed By Code"); 113 this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Ordered By Code"); 114 this.add(CP.class, false, 1, 12, new Object[]{ getMessage() }, "Unit Cost"); 115 this.add(EI.class, false, 1, 22, new Object[]{ getMessage() }, "Filler Order Number"); 116 this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Entered By Code"); 117 this.add(CE.class, false, 1, 80, new Object[]{ getMessage() }, "Procedure Code"); 118 this.add(CE.class, false, 0, 80, new Object[]{ getMessage() }, "Procedure Code Modifier"); 119 } catch(HL7Exception e) { 120 log.error("Unexpected error creating FT1 - this is probably a bug in the source code generator.", e); 121 } 122 } 123 124 125 126 /** 127 * Returns 128 * FT1-1: "Set ID - FT1" - creates it if necessary 129 */ 130 public SI getSetIDFT1() { 131 SI retVal = this.getTypedField(1, 0); 132 return retVal; 133 } 134 135 /** 136 * Returns 137 * FT1-1: "Set ID - FT1" - creates it if necessary 138 */ 139 public SI getFt11_SetIDFT1() { 140 SI retVal = this.getTypedField(1, 0); 141 return retVal; 142 } 143 144 145 146 /** 147 * Returns 148 * FT1-2: "Transaction ID" - creates it if necessary 149 */ 150 public ST getTransactionID() { 151 ST retVal = this.getTypedField(2, 0); 152 return retVal; 153 } 154 155 /** 156 * Returns 157 * FT1-2: "Transaction ID" - creates it if necessary 158 */ 159 public ST getFt12_TransactionID() { 160 ST retVal = this.getTypedField(2, 0); 161 return retVal; 162 } 163 164 165 166 /** 167 * Returns 168 * FT1-3: "Transaction Batch ID" - creates it if necessary 169 */ 170 public ST getTransactionBatchID() { 171 ST retVal = this.getTypedField(3, 0); 172 return retVal; 173 } 174 175 /** 176 * Returns 177 * FT1-3: "Transaction Batch ID" - creates it if necessary 178 */ 179 public ST getFt13_TransactionBatchID() { 180 ST retVal = this.getTypedField(3, 0); 181 return retVal; 182 } 183 184 185 186 /** 187 * Returns 188 * FT1-4: "Transaction Date" - creates it if necessary 189 */ 190 public TS getTransactionDate() { 191 TS retVal = this.getTypedField(4, 0); 192 return retVal; 193 } 194 195 /** 196 * Returns 197 * FT1-4: "Transaction Date" - creates it if necessary 198 */ 199 public TS getFt14_TransactionDate() { 200 TS retVal = this.getTypedField(4, 0); 201 return retVal; 202 } 203 204 205 206 /** 207 * Returns 208 * FT1-5: "Transaction Posting Date" - creates it if necessary 209 */ 210 public TS getTransactionPostingDate() { 211 TS retVal = this.getTypedField(5, 0); 212 return retVal; 213 } 214 215 /** 216 * Returns 217 * FT1-5: "Transaction Posting Date" - creates it if necessary 218 */ 219 public TS getFt15_TransactionPostingDate() { 220 TS retVal = this.getTypedField(5, 0); 221 return retVal; 222 } 223 224 225 226 /** 227 * Returns 228 * FT1-6: "Transaction Type" - creates it if necessary 229 */ 230 public IS getTransactionType() { 231 IS retVal = this.getTypedField(6, 0); 232 return retVal; 233 } 234 235 /** 236 * Returns 237 * FT1-6: "Transaction Type" - creates it if necessary 238 */ 239 public IS getFt16_TransactionType() { 240 IS retVal = this.getTypedField(6, 0); 241 return retVal; 242 } 243 244 245 246 /** 247 * Returns 248 * FT1-7: "Transaction Code" - creates it if necessary 249 */ 250 public CE getTransactionCode() { 251 CE retVal = this.getTypedField(7, 0); 252 return retVal; 253 } 254 255 /** 256 * Returns 257 * FT1-7: "Transaction Code" - creates it if necessary 258 */ 259 public CE getFt17_TransactionCode() { 260 CE retVal = this.getTypedField(7, 0); 261 return retVal; 262 } 263 264 265 266 /** 267 * Returns 268 * FT1-8: "Transaction Description" - creates it if necessary 269 */ 270 public ST getTransactionDescription() { 271 ST retVal = this.getTypedField(8, 0); 272 return retVal; 273 } 274 275 /** 276 * Returns 277 * FT1-8: "Transaction Description" - creates it if necessary 278 */ 279 public ST getFt18_TransactionDescription() { 280 ST retVal = this.getTypedField(8, 0); 281 return retVal; 282 } 283 284 285 286 /** 287 * Returns 288 * FT1-9: "Transaction Description - Alt" - creates it if necessary 289 */ 290 public ST getTransactionDescriptionAlt() { 291 ST retVal = this.getTypedField(9, 0); 292 return retVal; 293 } 294 295 /** 296 * Returns 297 * FT1-9: "Transaction Description - Alt" - creates it if necessary 298 */ 299 public ST getFt19_TransactionDescriptionAlt() { 300 ST retVal = this.getTypedField(9, 0); 301 return retVal; 302 } 303 304 305 306 /** 307 * Returns 308 * FT1-10: "Transaction Quantity" - creates it if necessary 309 */ 310 public NM getTransactionQuantity() { 311 NM retVal = this.getTypedField(10, 0); 312 return retVal; 313 } 314 315 /** 316 * Returns 317 * FT1-10: "Transaction Quantity" - creates it if necessary 318 */ 319 public NM getFt110_TransactionQuantity() { 320 NM retVal = this.getTypedField(10, 0); 321 return retVal; 322 } 323 324 325 326 /** 327 * Returns 328 * FT1-11: "Transaction Amount - Extended" - creates it if necessary 329 */ 330 public CP getTransactionAmountExtended() { 331 CP retVal = this.getTypedField(11, 0); 332 return retVal; 333 } 334 335 /** 336 * Returns 337 * FT1-11: "Transaction Amount - Extended" - creates it if necessary 338 */ 339 public CP getFt111_TransactionAmountExtended() { 340 CP retVal = this.getTypedField(11, 0); 341 return retVal; 342 } 343 344 345 346 /** 347 * Returns 348 * FT1-12: "Transaction Amount - Unit" - creates it if necessary 349 */ 350 public CP getTransactionAmountUnit() { 351 CP retVal = this.getTypedField(12, 0); 352 return retVal; 353 } 354 355 /** 356 * Returns 357 * FT1-12: "Transaction Amount - Unit" - creates it if necessary 358 */ 359 public CP getFt112_TransactionAmountUnit() { 360 CP retVal = this.getTypedField(12, 0); 361 return retVal; 362 } 363 364 365 366 /** 367 * Returns 368 * FT1-13: "Department Code" - creates it if necessary 369 */ 370 public CE getDepartmentCode() { 371 CE retVal = this.getTypedField(13, 0); 372 return retVal; 373 } 374 375 /** 376 * Returns 377 * FT1-13: "Department Code" - creates it if necessary 378 */ 379 public CE getFt113_DepartmentCode() { 380 CE retVal = this.getTypedField(13, 0); 381 return retVal; 382 } 383 384 385 386 /** 387 * Returns 388 * FT1-14: "Insurance Plan ID" - creates it if necessary 389 */ 390 public CE getInsurancePlanID() { 391 CE retVal = this.getTypedField(14, 0); 392 return retVal; 393 } 394 395 /** 396 * Returns 397 * FT1-14: "Insurance Plan ID" - creates it if necessary 398 */ 399 public CE getFt114_InsurancePlanID() { 400 CE retVal = this.getTypedField(14, 0); 401 return retVal; 402 } 403 404 405 406 /** 407 * Returns 408 * FT1-15: "Insurance Amount" - creates it if necessary 409 */ 410 public CP getInsuranceAmount() { 411 CP retVal = this.getTypedField(15, 0); 412 return retVal; 413 } 414 415 /** 416 * Returns 417 * FT1-15: "Insurance Amount" - creates it if necessary 418 */ 419 public CP getFt115_InsuranceAmount() { 420 CP retVal = this.getTypedField(15, 0); 421 return retVal; 422 } 423 424 425 426 /** 427 * Returns 428 * FT1-16: "Assigned Patient Location" - creates it if necessary 429 */ 430 public PL getAssignedPatientLocation() { 431 PL retVal = this.getTypedField(16, 0); 432 return retVal; 433 } 434 435 /** 436 * Returns 437 * FT1-16: "Assigned Patient Location" - creates it if necessary 438 */ 439 public PL getFt116_AssignedPatientLocation() { 440 PL retVal = this.getTypedField(16, 0); 441 return retVal; 442 } 443 444 445 446 /** 447 * Returns 448 * FT1-17: "Fee Schedule" - creates it if necessary 449 */ 450 public IS getFeeSchedule() { 451 IS retVal = this.getTypedField(17, 0); 452 return retVal; 453 } 454 455 /** 456 * Returns 457 * FT1-17: "Fee Schedule" - creates it if necessary 458 */ 459 public IS getFt117_FeeSchedule() { 460 IS retVal = this.getTypedField(17, 0); 461 return retVal; 462 } 463 464 465 466 /** 467 * Returns 468 * FT1-18: "Patient Type" - creates it if necessary 469 */ 470 public IS getPatientType() { 471 IS retVal = this.getTypedField(18, 0); 472 return retVal; 473 } 474 475 /** 476 * Returns 477 * FT1-18: "Patient Type" - creates it if necessary 478 */ 479 public IS getFt118_PatientType() { 480 IS retVal = this.getTypedField(18, 0); 481 return retVal; 482 } 483 484 485 /** 486 * Returns all repetitions of Diagnosis Code - FT1 (FT1-19). 487 */ 488 public CE[] getDiagnosisCodeFT1() { 489 CE[] retVal = this.getTypedField(19, new CE[0]); 490 return retVal; 491 } 492 493 494 /** 495 * Returns all repetitions of Diagnosis Code - FT1 (FT1-19). 496 */ 497 public CE[] getFt119_DiagnosisCodeFT1() { 498 CE[] retVal = this.getTypedField(19, new CE[0]); 499 return retVal; 500 } 501 502 503 /** 504 * Returns a count of the current number of repetitions of Diagnosis Code - FT1 (FT1-19). 505 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 506 * it will return zero. 507 */ 508 public int getDiagnosisCodeFT1Reps() { 509 return this.getReps(19); 510 } 511 512 513 /** 514 * Returns a specific repetition of 515 * FT1-19: "Diagnosis Code - FT1" - creates it if necessary 516 * 517 * @param rep The repetition index (0-indexed) 518 */ 519 public CE getDiagnosisCodeFT1(int rep) { 520 CE retVal = this.getTypedField(19, rep); 521 return retVal; 522 } 523 524 /** 525 * Returns a specific repetition of 526 * FT1-19: "Diagnosis Code - FT1" - creates it if necessary 527 * 528 * @param rep The repetition index (0-indexed) 529 */ 530 public CE getFt119_DiagnosisCodeFT1(int rep) { 531 CE retVal = this.getTypedField(19, rep); 532 return retVal; 533 } 534 535 /** 536 * Returns a count of the current number of repetitions of Diagnosis Code - FT1 (FT1-19). 537 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 538 * it will return zero. 539 */ 540 public int getFt119_DiagnosisCodeFT1Reps() { 541 return this.getReps(19); 542 } 543 544 545 /** 546 * Inserts a repetition of 547 * FT1-19: "Diagnosis Code - FT1" at a specific index 548 * 549 * @param rep The repetition index (0-indexed) 550 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 551 */ 552 public CE insertDiagnosisCodeFT1(int rep) throws HL7Exception { 553 return (CE) super.insertRepetition(19, rep); 554 } 555 556 557 /** 558 * Inserts a repetition of 559 * FT1-19: "Diagnosis Code - FT1" at a specific index 560 * 561 * @param rep The repetition index (0-indexed) 562 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 563 */ 564 public CE insertFt119_DiagnosisCodeFT1(int rep) throws HL7Exception { 565 return (CE) super.insertRepetition(19, rep); 566 } 567 568 569 /** 570 * Removes a repetition of 571 * FT1-19: "Diagnosis Code - FT1" at a specific index 572 * 573 * @param rep The repetition index (0-indexed) 574 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 575 */ 576 public CE removeDiagnosisCodeFT1(int rep) throws HL7Exception { 577 return (CE) super.removeRepetition(19, rep); 578 } 579 580 581 /** 582 * Removes a repetition of 583 * FT1-19: "Diagnosis Code - FT1" at a specific index 584 * 585 * @param rep The repetition index (0-indexed) 586 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 587 */ 588 public CE removeFt119_DiagnosisCodeFT1(int rep) throws HL7Exception { 589 return (CE) super.removeRepetition(19, rep); 590 } 591 592 593 594 /** 595 * Returns all repetitions of Performed By Code (FT1-20). 596 */ 597 public XCN[] getPerformedByCode() { 598 XCN[] retVal = this.getTypedField(20, new XCN[0]); 599 return retVal; 600 } 601 602 603 /** 604 * Returns all repetitions of Performed By Code (FT1-20). 605 */ 606 public XCN[] getFt120_PerformedByCode() { 607 XCN[] retVal = this.getTypedField(20, new XCN[0]); 608 return retVal; 609 } 610 611 612 /** 613 * Returns a count of the current number of repetitions of Performed By Code (FT1-20). 614 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 615 * it will return zero. 616 */ 617 public int getPerformedByCodeReps() { 618 return this.getReps(20); 619 } 620 621 622 /** 623 * Returns a specific repetition of 624 * FT1-20: "Performed By Code" - creates it if necessary 625 * 626 * @param rep The repetition index (0-indexed) 627 */ 628 public XCN getPerformedByCode(int rep) { 629 XCN retVal = this.getTypedField(20, rep); 630 return retVal; 631 } 632 633 /** 634 * Returns a specific repetition of 635 * FT1-20: "Performed By Code" - creates it if necessary 636 * 637 * @param rep The repetition index (0-indexed) 638 */ 639 public XCN getFt120_PerformedByCode(int rep) { 640 XCN retVal = this.getTypedField(20, rep); 641 return retVal; 642 } 643 644 /** 645 * Returns a count of the current number of repetitions of Performed By Code (FT1-20). 646 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 647 * it will return zero. 648 */ 649 public int getFt120_PerformedByCodeReps() { 650 return this.getReps(20); 651 } 652 653 654 /** 655 * Inserts a repetition of 656 * FT1-20: "Performed By Code" at a specific index 657 * 658 * @param rep The repetition index (0-indexed) 659 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 660 */ 661 public XCN insertPerformedByCode(int rep) throws HL7Exception { 662 return (XCN) super.insertRepetition(20, rep); 663 } 664 665 666 /** 667 * Inserts a repetition of 668 * FT1-20: "Performed By Code" at a specific index 669 * 670 * @param rep The repetition index (0-indexed) 671 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 672 */ 673 public XCN insertFt120_PerformedByCode(int rep) throws HL7Exception { 674 return (XCN) super.insertRepetition(20, rep); 675 } 676 677 678 /** 679 * Removes a repetition of 680 * FT1-20: "Performed By Code" at a specific index 681 * 682 * @param rep The repetition index (0-indexed) 683 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 684 */ 685 public XCN removePerformedByCode(int rep) throws HL7Exception { 686 return (XCN) super.removeRepetition(20, rep); 687 } 688 689 690 /** 691 * Removes a repetition of 692 * FT1-20: "Performed By Code" at a specific index 693 * 694 * @param rep The repetition index (0-indexed) 695 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 696 */ 697 public XCN removeFt120_PerformedByCode(int rep) throws HL7Exception { 698 return (XCN) super.removeRepetition(20, rep); 699 } 700 701 702 703 /** 704 * Returns all repetitions of Ordered By Code (FT1-21). 705 */ 706 public XCN[] getOrderedByCode() { 707 XCN[] retVal = this.getTypedField(21, new XCN[0]); 708 return retVal; 709 } 710 711 712 /** 713 * Returns all repetitions of Ordered By Code (FT1-21). 714 */ 715 public XCN[] getFt121_OrderedByCode() { 716 XCN[] retVal = this.getTypedField(21, new XCN[0]); 717 return retVal; 718 } 719 720 721 /** 722 * Returns a count of the current number of repetitions of Ordered By Code (FT1-21). 723 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 724 * it will return zero. 725 */ 726 public int getOrderedByCodeReps() { 727 return this.getReps(21); 728 } 729 730 731 /** 732 * Returns a specific repetition of 733 * FT1-21: "Ordered By Code" - creates it if necessary 734 * 735 * @param rep The repetition index (0-indexed) 736 */ 737 public XCN getOrderedByCode(int rep) { 738 XCN retVal = this.getTypedField(21, rep); 739 return retVal; 740 } 741 742 /** 743 * Returns a specific repetition of 744 * FT1-21: "Ordered By Code" - creates it if necessary 745 * 746 * @param rep The repetition index (0-indexed) 747 */ 748 public XCN getFt121_OrderedByCode(int rep) { 749 XCN retVal = this.getTypedField(21, rep); 750 return retVal; 751 } 752 753 /** 754 * Returns a count of the current number of repetitions of Ordered By Code (FT1-21). 755 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 756 * it will return zero. 757 */ 758 public int getFt121_OrderedByCodeReps() { 759 return this.getReps(21); 760 } 761 762 763 /** 764 * Inserts a repetition of 765 * FT1-21: "Ordered By Code" at a specific index 766 * 767 * @param rep The repetition index (0-indexed) 768 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 769 */ 770 public XCN insertOrderedByCode(int rep) throws HL7Exception { 771 return (XCN) super.insertRepetition(21, rep); 772 } 773 774 775 /** 776 * Inserts a repetition of 777 * FT1-21: "Ordered By Code" at a specific index 778 * 779 * @param rep The repetition index (0-indexed) 780 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 781 */ 782 public XCN insertFt121_OrderedByCode(int rep) throws HL7Exception { 783 return (XCN) super.insertRepetition(21, rep); 784 } 785 786 787 /** 788 * Removes a repetition of 789 * FT1-21: "Ordered By Code" at a specific index 790 * 791 * @param rep The repetition index (0-indexed) 792 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 793 */ 794 public XCN removeOrderedByCode(int rep) throws HL7Exception { 795 return (XCN) super.removeRepetition(21, rep); 796 } 797 798 799 /** 800 * Removes a repetition of 801 * FT1-21: "Ordered By Code" at a specific index 802 * 803 * @param rep The repetition index (0-indexed) 804 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 805 */ 806 public XCN removeFt121_OrderedByCode(int rep) throws HL7Exception { 807 return (XCN) super.removeRepetition(21, rep); 808 } 809 810 811 812 813 /** 814 * Returns 815 * FT1-22: "Unit Cost" - creates it if necessary 816 */ 817 public CP getUnitCost() { 818 CP retVal = this.getTypedField(22, 0); 819 return retVal; 820 } 821 822 /** 823 * Returns 824 * FT1-22: "Unit Cost" - creates it if necessary 825 */ 826 public CP getFt122_UnitCost() { 827 CP retVal = this.getTypedField(22, 0); 828 return retVal; 829 } 830 831 832 833 /** 834 * Returns 835 * FT1-23: "Filler Order Number" - creates it if necessary 836 */ 837 public EI getFillerOrderNumber() { 838 EI retVal = this.getTypedField(23, 0); 839 return retVal; 840 } 841 842 /** 843 * Returns 844 * FT1-23: "Filler Order Number" - creates it if necessary 845 */ 846 public EI getFt123_FillerOrderNumber() { 847 EI retVal = this.getTypedField(23, 0); 848 return retVal; 849 } 850 851 852 /** 853 * Returns all repetitions of Entered By Code (FT1-24). 854 */ 855 public XCN[] getEnteredByCode() { 856 XCN[] retVal = this.getTypedField(24, new XCN[0]); 857 return retVal; 858 } 859 860 861 /** 862 * Returns all repetitions of Entered By Code (FT1-24). 863 */ 864 public XCN[] getFt124_EnteredByCode() { 865 XCN[] retVal = this.getTypedField(24, new XCN[0]); 866 return retVal; 867 } 868 869 870 /** 871 * Returns a count of the current number of repetitions of Entered By Code (FT1-24). 872 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 873 * it will return zero. 874 */ 875 public int getEnteredByCodeReps() { 876 return this.getReps(24); 877 } 878 879 880 /** 881 * Returns a specific repetition of 882 * FT1-24: "Entered By Code" - creates it if necessary 883 * 884 * @param rep The repetition index (0-indexed) 885 */ 886 public XCN getEnteredByCode(int rep) { 887 XCN retVal = this.getTypedField(24, rep); 888 return retVal; 889 } 890 891 /** 892 * Returns a specific repetition of 893 * FT1-24: "Entered By Code" - creates it if necessary 894 * 895 * @param rep The repetition index (0-indexed) 896 */ 897 public XCN getFt124_EnteredByCode(int rep) { 898 XCN retVal = this.getTypedField(24, rep); 899 return retVal; 900 } 901 902 /** 903 * Returns a count of the current number of repetitions of Entered By Code (FT1-24). 904 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 905 * it will return zero. 906 */ 907 public int getFt124_EnteredByCodeReps() { 908 return this.getReps(24); 909 } 910 911 912 /** 913 * Inserts a repetition of 914 * FT1-24: "Entered By Code" at a specific index 915 * 916 * @param rep The repetition index (0-indexed) 917 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 918 */ 919 public XCN insertEnteredByCode(int rep) throws HL7Exception { 920 return (XCN) super.insertRepetition(24, rep); 921 } 922 923 924 /** 925 * Inserts a repetition of 926 * FT1-24: "Entered By Code" at a specific index 927 * 928 * @param rep The repetition index (0-indexed) 929 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 930 */ 931 public XCN insertFt124_EnteredByCode(int rep) throws HL7Exception { 932 return (XCN) super.insertRepetition(24, rep); 933 } 934 935 936 /** 937 * Removes a repetition of 938 * FT1-24: "Entered By Code" at a specific index 939 * 940 * @param rep The repetition index (0-indexed) 941 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 942 */ 943 public XCN removeEnteredByCode(int rep) throws HL7Exception { 944 return (XCN) super.removeRepetition(24, rep); 945 } 946 947 948 /** 949 * Removes a repetition of 950 * FT1-24: "Entered By Code" at a specific index 951 * 952 * @param rep The repetition index (0-indexed) 953 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 954 */ 955 public XCN removeFt124_EnteredByCode(int rep) throws HL7Exception { 956 return (XCN) super.removeRepetition(24, rep); 957 } 958 959 960 961 962 /** 963 * Returns 964 * FT1-25: "Procedure Code" - creates it if necessary 965 */ 966 public CE getProcedureCode() { 967 CE retVal = this.getTypedField(25, 0); 968 return retVal; 969 } 970 971 /** 972 * Returns 973 * FT1-25: "Procedure Code" - creates it if necessary 974 */ 975 public CE getFt125_ProcedureCode() { 976 CE retVal = this.getTypedField(25, 0); 977 return retVal; 978 } 979 980 981 /** 982 * Returns all repetitions of Procedure Code Modifier (FT1-26). 983 */ 984 public CE[] getProcedureCodeModifier() { 985 CE[] retVal = this.getTypedField(26, new CE[0]); 986 return retVal; 987 } 988 989 990 /** 991 * Returns all repetitions of Procedure Code Modifier (FT1-26). 992 */ 993 public CE[] getFt126_ProcedureCodeModifier() { 994 CE[] retVal = this.getTypedField(26, new CE[0]); 995 return retVal; 996 } 997 998 999 /** 1000 * Returns a count of the current number of repetitions of Procedure Code Modifier (FT1-26). 1001 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1002 * it will return zero. 1003 */ 1004 public int getProcedureCodeModifierReps() { 1005 return this.getReps(26); 1006 } 1007 1008 1009 /** 1010 * Returns a specific repetition of 1011 * FT1-26: "Procedure Code Modifier" - creates it if necessary 1012 * 1013 * @param rep The repetition index (0-indexed) 1014 */ 1015 public CE getProcedureCodeModifier(int rep) { 1016 CE retVal = this.getTypedField(26, rep); 1017 return retVal; 1018 } 1019 1020 /** 1021 * Returns a specific repetition of 1022 * FT1-26: "Procedure Code Modifier" - creates it if necessary 1023 * 1024 * @param rep The repetition index (0-indexed) 1025 */ 1026 public CE getFt126_ProcedureCodeModifier(int rep) { 1027 CE retVal = this.getTypedField(26, rep); 1028 return retVal; 1029 } 1030 1031 /** 1032 * Returns a count of the current number of repetitions of Procedure Code Modifier (FT1-26). 1033 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1034 * it will return zero. 1035 */ 1036 public int getFt126_ProcedureCodeModifierReps() { 1037 return this.getReps(26); 1038 } 1039 1040 1041 /** 1042 * Inserts a repetition of 1043 * FT1-26: "Procedure Code Modifier" at a specific index 1044 * 1045 * @param rep The repetition index (0-indexed) 1046 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1047 */ 1048 public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 1049 return (CE) super.insertRepetition(26, rep); 1050 } 1051 1052 1053 /** 1054 * Inserts a repetition of 1055 * FT1-26: "Procedure Code Modifier" at a specific index 1056 * 1057 * @param rep The repetition index (0-indexed) 1058 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1059 */ 1060 public CE insertFt126_ProcedureCodeModifier(int rep) throws HL7Exception { 1061 return (CE) super.insertRepetition(26, rep); 1062 } 1063 1064 1065 /** 1066 * Removes a repetition of 1067 * FT1-26: "Procedure Code Modifier" at a specific index 1068 * 1069 * @param rep The repetition index (0-indexed) 1070 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1071 */ 1072 public CE removeProcedureCodeModifier(int rep) throws HL7Exception { 1073 return (CE) super.removeRepetition(26, rep); 1074 } 1075 1076 1077 /** 1078 * Removes a repetition of 1079 * FT1-26: "Procedure Code Modifier" at a specific index 1080 * 1081 * @param rep The repetition index (0-indexed) 1082 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1083 */ 1084 public CE removeFt126_ProcedureCodeModifier(int rep) throws HL7Exception { 1085 return (CE) super.removeRepetition(26, rep); 1086 } 1087 1088 1089 1090 1091 1092 1093 /** {@inheritDoc} */ 1094 protected Type createNewTypeWithoutReflection(int field) { 1095 switch (field) { 1096 case 0: return new SI(getMessage()); 1097 case 1: return new ST(getMessage()); 1098 case 2: return new ST(getMessage()); 1099 case 3: return new TS(getMessage()); 1100 case 4: return new TS(getMessage()); 1101 case 5: return new IS(getMessage(), new Integer( 17 )); 1102 case 6: return new CE(getMessage()); 1103 case 7: return new ST(getMessage()); 1104 case 8: return new ST(getMessage()); 1105 case 9: return new NM(getMessage()); 1106 case 10: return new CP(getMessage()); 1107 case 11: return new CP(getMessage()); 1108 case 12: return new CE(getMessage()); 1109 case 13: return new CE(getMessage()); 1110 case 14: return new CP(getMessage()); 1111 case 15: return new PL(getMessage()); 1112 case 16: return new IS(getMessage(), new Integer( 24 )); 1113 case 17: return new IS(getMessage(), new Integer( 18 )); 1114 case 18: return new CE(getMessage()); 1115 case 19: return new XCN(getMessage()); 1116 case 20: return new XCN(getMessage()); 1117 case 21: return new CP(getMessage()); 1118 case 22: return new EI(getMessage()); 1119 case 23: return new XCN(getMessage()); 1120 case 24: return new CE(getMessage()); 1121 case 25: return new CE(getMessage()); 1122 default: return null; 1123 } 1124 } 1125 1126 1127} 1128