001/* 002 * This class is an auto-generated source file for a HAPI 003 * HL7 v2.x standard structure class. 004 * 005 * For more information, visit: http://hl7api.sourceforge.net/ 006 * 007 * The contents of this file are subject to the Mozilla Public License Version 1.1 008 * (the "License"); you may not use this file except in compliance with the License. 009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 010 * Software distributed under the License is distributed on an "AS IS" basis, 011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 012 * specific language governing rights and limitations under the License. 013 * 014 * The Original Code is "[file_name]". Description: 015 * "[one_line_description]" 016 * 017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 018 * 2012. All Rights Reserved. 019 * 020 * Contributor(s): ______________________________________. 021 * 022 * Alternatively, the contents of this file may be used under the terms of the 023 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are 024 * applicable instead of those above. If you wish to allow use of your version of this 025 * file only under the terms of the GPL and not to allow others to use your version 026 * of this file under the MPL, indicate your decision by deleting the provisions above 027 * and replace them with the notice and other provisions required by the GPL License. 028 * If you do not delete the provisions above, a recipient may use your version of 029 * this file under either the MPL or the GPL. 030 * 031 */ 032 033 034package ca.uhn.hl7v2.model.v251.segment; 035 036// import ca.uhn.hl7v2.model.v251.group.*; 037import ca.uhn.hl7v2.model.v251.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 RXD message segment (Pharmacy/Treatment Dispense). 050 * This segment has the following fields:</p> 051 * <ul> 052 * <li>RXD-1: Dispense Sub-ID Counter (NM) <b> </b> 053 * <li>RXD-2: Dispense/Give Code (CE) <b> </b> 054 * <li>RXD-3: Date/Time Dispensed (TS) <b> </b> 055 * <li>RXD-4: Actual Dispense Amount (NM) <b> </b> 056 * <li>RXD-5: Actual Dispense Units (CE) <b>optional </b> 057 * <li>RXD-6: Actual Dosage Form (CE) <b>optional </b> 058 * <li>RXD-7: Prescription Number (ST) <b> </b> 059 * <li>RXD-8: Number of Refills Remaining (NM) <b>optional </b> 060 * <li>RXD-9: Dispense Notes (ST) <b>optional repeating</b> 061 * <li>RXD-10: Dispensing Provider (XCN) <b>optional repeating</b> 062 * <li>RXD-11: Substitution Status (ID) <b>optional </b> 063 * <li>RXD-12: Total Daily Dose (CQ) <b>optional </b> 064 * <li>RXD-13: Dispense-to Location (LA2) <b>optional </b> 065 * <li>RXD-14: Needs Human Review (ID) <b>optional </b> 066 * <li>RXD-15: Pharmacy/Treatment Supplier's Special Dispensing Instructions (CE) <b>optional repeating</b> 067 * <li>RXD-16: Actual Strength (NM) <b>optional </b> 068 * <li>RXD-17: Actual Strength Unit (CE) <b>optional </b> 069 * <li>RXD-18: Substance Lot Number (ST) <b>optional repeating</b> 070 * <li>RXD-19: Substance Expiration Date (TS) <b>optional repeating</b> 071 * <li>RXD-20: Substance Manufacturer Name (CE) <b>optional repeating</b> 072 * <li>RXD-21: Indication (CE) <b>optional repeating</b> 073 * <li>RXD-22: Dispense Package Size (NM) <b>optional </b> 074 * <li>RXD-23: Dispense Package Size Unit (CE) <b>optional </b> 075 * <li>RXD-24: Dispense Package Method (ID) <b>optional </b> 076 * <li>RXD-25: Supplementary Code (CE) <b>optional repeating</b> 077 * <li>RXD-26: Initiating Location (CE) <b>optional </b> 078 * <li>RXD-27: Packaging/Assembly Location (CE) <b>optional </b> 079 * <li>RXD-28: Actual Drug Strength Volume (NM) <b>optional </b> 080 * <li>RXD-29: Actual Drug Strength Volume Units (CWE) <b>optional </b> 081 * <li>RXD-30: Dispense to Pharmacy (CWE) <b>optional </b> 082 * <li>RXD-31: Dispense to Pharmacy Address (XAD) <b>optional </b> 083 * <li>RXD-32: Pharmacy Order Type (ID) <b>optional </b> 084 * <li>RXD-33: Dispense Type (CWE) <b>optional </b> 085 * </ul> 086 */ 087@SuppressWarnings("unused") 088public class RXD extends AbstractSegment { 089 090 /** 091 * Creates a new RXD segment 092 */ 093 public RXD(Group parent, ModelClassFactory factory) { 094 super(parent, factory); 095 init(factory); 096 } 097 098 private void init(ModelClassFactory factory) { 099 try { 100 this.add(NM.class, true, 1, 4, new Object[]{ getMessage() }, "Dispense Sub-ID Counter"); 101 this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Dispense/Give Code"); 102 this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Date/Time Dispensed"); 103 this.add(NM.class, true, 1, 20, new Object[]{ getMessage() }, "Actual Dispense Amount"); 104 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Actual Dispense Units"); 105 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Actual Dosage Form"); 106 this.add(ST.class, true, 1, 20, new Object[]{ getMessage() }, "Prescription Number"); 107 this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Number of Refills Remaining"); 108 this.add(ST.class, false, 0, 200, new Object[]{ getMessage() }, "Dispense Notes"); 109 this.add(XCN.class, false, 0, 200, new Object[]{ getMessage() }, "Dispensing Provider"); 110 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(167) }, "Substitution Status"); 111 this.add(CQ.class, false, 1, 10, new Object[]{ getMessage() }, "Total Daily Dose"); 112 this.add(LA2.class, false, 1, 200, new Object[]{ getMessage() }, "Dispense-to Location"); 113 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(136) }, "Needs Human Review"); 114 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Pharmacy/Treatment Supplier's Special Dispensing Instructions"); 115 this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Actual Strength"); 116 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Actual Strength Unit"); 117 this.add(ST.class, false, 0, 20, new Object[]{ getMessage() }, "Substance Lot Number"); 118 this.add(TS.class, false, 0, 26, new Object[]{ getMessage() }, "Substance Expiration Date"); 119 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Substance Manufacturer Name"); 120 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Indication"); 121 this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Dispense Package Size"); 122 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Dispense Package Size Unit"); 123 this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(321) }, "Dispense Package Method"); 124 this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Supplementary Code"); 125 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Initiating Location"); 126 this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Packaging/Assembly Location"); 127 this.add(NM.class, false, 1, 5, new Object[]{ getMessage() }, "Actual Drug Strength Volume"); 128 this.add(CWE.class, false, 1, 250, new Object[]{ getMessage() }, "Actual Drug Strength Volume Units"); 129 this.add(CWE.class, false, 1, 180, new Object[]{ getMessage() }, "Dispense to Pharmacy"); 130 this.add(XAD.class, false, 1, 106, new Object[]{ getMessage() }, "Dispense to Pharmacy Address"); 131 this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(480) }, "Pharmacy Order Type"); 132 this.add(CWE.class, false, 1, 250, new Object[]{ getMessage() }, "Dispense Type"); 133 } catch(HL7Exception e) { 134 log.error("Unexpected error creating RXD - this is probably a bug in the source code generator.", e); 135 } 136 } 137 138 139 140 /** 141 * Returns 142 * RXD-1: "Dispense Sub-ID Counter" - creates it if necessary 143 */ 144 public NM getDispenseSubIDCounter() { 145 NM retVal = this.getTypedField(1, 0); 146 return retVal; 147 } 148 149 /** 150 * Returns 151 * RXD-1: "Dispense Sub-ID Counter" - creates it if necessary 152 */ 153 public NM getRxd1_DispenseSubIDCounter() { 154 NM retVal = this.getTypedField(1, 0); 155 return retVal; 156 } 157 158 159 160 /** 161 * Returns 162 * RXD-2: "Dispense/Give Code" - creates it if necessary 163 */ 164 public CE getDispenseGiveCode() { 165 CE retVal = this.getTypedField(2, 0); 166 return retVal; 167 } 168 169 /** 170 * Returns 171 * RXD-2: "Dispense/Give Code" - creates it if necessary 172 */ 173 public CE getRxd2_DispenseGiveCode() { 174 CE retVal = this.getTypedField(2, 0); 175 return retVal; 176 } 177 178 179 180 /** 181 * Returns 182 * RXD-3: "Date/Time Dispensed" - creates it if necessary 183 */ 184 public TS getDateTimeDispensed() { 185 TS retVal = this.getTypedField(3, 0); 186 return retVal; 187 } 188 189 /** 190 * Returns 191 * RXD-3: "Date/Time Dispensed" - creates it if necessary 192 */ 193 public TS getRxd3_DateTimeDispensed() { 194 TS retVal = this.getTypedField(3, 0); 195 return retVal; 196 } 197 198 199 200 /** 201 * Returns 202 * RXD-4: "Actual Dispense Amount" - creates it if necessary 203 */ 204 public NM getActualDispenseAmount() { 205 NM retVal = this.getTypedField(4, 0); 206 return retVal; 207 } 208 209 /** 210 * Returns 211 * RXD-4: "Actual Dispense Amount" - creates it if necessary 212 */ 213 public NM getRxd4_ActualDispenseAmount() { 214 NM retVal = this.getTypedField(4, 0); 215 return retVal; 216 } 217 218 219 220 /** 221 * Returns 222 * RXD-5: "Actual Dispense Units" - creates it if necessary 223 */ 224 public CE getActualDispenseUnits() { 225 CE retVal = this.getTypedField(5, 0); 226 return retVal; 227 } 228 229 /** 230 * Returns 231 * RXD-5: "Actual Dispense Units" - creates it if necessary 232 */ 233 public CE getRxd5_ActualDispenseUnits() { 234 CE retVal = this.getTypedField(5, 0); 235 return retVal; 236 } 237 238 239 240 /** 241 * Returns 242 * RXD-6: "Actual Dosage Form" - creates it if necessary 243 */ 244 public CE getActualDosageForm() { 245 CE retVal = this.getTypedField(6, 0); 246 return retVal; 247 } 248 249 /** 250 * Returns 251 * RXD-6: "Actual Dosage Form" - creates it if necessary 252 */ 253 public CE getRxd6_ActualDosageForm() { 254 CE retVal = this.getTypedField(6, 0); 255 return retVal; 256 } 257 258 259 260 /** 261 * Returns 262 * RXD-7: "Prescription Number" - creates it if necessary 263 */ 264 public ST getPrescriptionNumber() { 265 ST retVal = this.getTypedField(7, 0); 266 return retVal; 267 } 268 269 /** 270 * Returns 271 * RXD-7: "Prescription Number" - creates it if necessary 272 */ 273 public ST getRxd7_PrescriptionNumber() { 274 ST retVal = this.getTypedField(7, 0); 275 return retVal; 276 } 277 278 279 280 /** 281 * Returns 282 * RXD-8: "Number of Refills Remaining" - creates it if necessary 283 */ 284 public NM getNumberOfRefillsRemaining() { 285 NM retVal = this.getTypedField(8, 0); 286 return retVal; 287 } 288 289 /** 290 * Returns 291 * RXD-8: "Number of Refills Remaining" - creates it if necessary 292 */ 293 public NM getRxd8_NumberOfRefillsRemaining() { 294 NM retVal = this.getTypedField(8, 0); 295 return retVal; 296 } 297 298 299 /** 300 * Returns all repetitions of Dispense Notes (RXD-9). 301 */ 302 public ST[] getDispenseNotes() { 303 ST[] retVal = this.getTypedField(9, new ST[0]); 304 return retVal; 305 } 306 307 308 /** 309 * Returns all repetitions of Dispense Notes (RXD-9). 310 */ 311 public ST[] getRxd9_DispenseNotes() { 312 ST[] retVal = this.getTypedField(9, new ST[0]); 313 return retVal; 314 } 315 316 317 /** 318 * Returns a count of the current number of repetitions of Dispense Notes (RXD-9). 319 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 320 * it will return zero. 321 */ 322 public int getDispenseNotesReps() { 323 return this.getReps(9); 324 } 325 326 327 /** 328 * Returns a specific repetition of 329 * RXD-9: "Dispense Notes" - creates it if necessary 330 * 331 * @param rep The repetition index (0-indexed) 332 */ 333 public ST getDispenseNotes(int rep) { 334 ST retVal = this.getTypedField(9, rep); 335 return retVal; 336 } 337 338 /** 339 * Returns a specific repetition of 340 * RXD-9: "Dispense Notes" - creates it if necessary 341 * 342 * @param rep The repetition index (0-indexed) 343 */ 344 public ST getRxd9_DispenseNotes(int rep) { 345 ST retVal = this.getTypedField(9, rep); 346 return retVal; 347 } 348 349 /** 350 * Returns a count of the current number of repetitions of Dispense Notes (RXD-9). 351 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 352 * it will return zero. 353 */ 354 public int getRxd9_DispenseNotesReps() { 355 return this.getReps(9); 356 } 357 358 359 /** 360 * Inserts a repetition of 361 * RXD-9: "Dispense Notes" at a specific index 362 * 363 * @param rep The repetition index (0-indexed) 364 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 365 */ 366 public ST insertDispenseNotes(int rep) throws HL7Exception { 367 return (ST) super.insertRepetition(9, rep); 368 } 369 370 371 /** 372 * Inserts a repetition of 373 * RXD-9: "Dispense Notes" at a specific index 374 * 375 * @param rep The repetition index (0-indexed) 376 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 377 */ 378 public ST insertRxd9_DispenseNotes(int rep) throws HL7Exception { 379 return (ST) super.insertRepetition(9, rep); 380 } 381 382 383 /** 384 * Removes a repetition of 385 * RXD-9: "Dispense Notes" at a specific index 386 * 387 * @param rep The repetition index (0-indexed) 388 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 389 */ 390 public ST removeDispenseNotes(int rep) throws HL7Exception { 391 return (ST) super.removeRepetition(9, rep); 392 } 393 394 395 /** 396 * Removes a repetition of 397 * RXD-9: "Dispense Notes" at a specific index 398 * 399 * @param rep The repetition index (0-indexed) 400 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 401 */ 402 public ST removeRxd9_DispenseNotes(int rep) throws HL7Exception { 403 return (ST) super.removeRepetition(9, rep); 404 } 405 406 407 408 /** 409 * Returns all repetitions of Dispensing Provider (RXD-10). 410 */ 411 public XCN[] getDispensingProvider() { 412 XCN[] retVal = this.getTypedField(10, new XCN[0]); 413 return retVal; 414 } 415 416 417 /** 418 * Returns all repetitions of Dispensing Provider (RXD-10). 419 */ 420 public XCN[] getRxd10_DispensingProvider() { 421 XCN[] retVal = this.getTypedField(10, new XCN[0]); 422 return retVal; 423 } 424 425 426 /** 427 * Returns a count of the current number of repetitions of Dispensing Provider (RXD-10). 428 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 429 * it will return zero. 430 */ 431 public int getDispensingProviderReps() { 432 return this.getReps(10); 433 } 434 435 436 /** 437 * Returns a specific repetition of 438 * RXD-10: "Dispensing Provider" - creates it if necessary 439 * 440 * @param rep The repetition index (0-indexed) 441 */ 442 public XCN getDispensingProvider(int rep) { 443 XCN retVal = this.getTypedField(10, rep); 444 return retVal; 445 } 446 447 /** 448 * Returns a specific repetition of 449 * RXD-10: "Dispensing Provider" - creates it if necessary 450 * 451 * @param rep The repetition index (0-indexed) 452 */ 453 public XCN getRxd10_DispensingProvider(int rep) { 454 XCN retVal = this.getTypedField(10, rep); 455 return retVal; 456 } 457 458 /** 459 * Returns a count of the current number of repetitions of Dispensing Provider (RXD-10). 460 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 461 * it will return zero. 462 */ 463 public int getRxd10_DispensingProviderReps() { 464 return this.getReps(10); 465 } 466 467 468 /** 469 * Inserts a repetition of 470 * RXD-10: "Dispensing Provider" at a specific index 471 * 472 * @param rep The repetition index (0-indexed) 473 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 474 */ 475 public XCN insertDispensingProvider(int rep) throws HL7Exception { 476 return (XCN) super.insertRepetition(10, rep); 477 } 478 479 480 /** 481 * Inserts a repetition of 482 * RXD-10: "Dispensing Provider" at a specific index 483 * 484 * @param rep The repetition index (0-indexed) 485 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 486 */ 487 public XCN insertRxd10_DispensingProvider(int rep) throws HL7Exception { 488 return (XCN) super.insertRepetition(10, rep); 489 } 490 491 492 /** 493 * Removes a repetition of 494 * RXD-10: "Dispensing Provider" at a specific index 495 * 496 * @param rep The repetition index (0-indexed) 497 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 498 */ 499 public XCN removeDispensingProvider(int rep) throws HL7Exception { 500 return (XCN) super.removeRepetition(10, rep); 501 } 502 503 504 /** 505 * Removes a repetition of 506 * RXD-10: "Dispensing Provider" at a specific index 507 * 508 * @param rep The repetition index (0-indexed) 509 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 510 */ 511 public XCN removeRxd10_DispensingProvider(int rep) throws HL7Exception { 512 return (XCN) super.removeRepetition(10, rep); 513 } 514 515 516 517 518 /** 519 * Returns 520 * RXD-11: "Substitution Status" - creates it if necessary 521 */ 522 public ID getSubstitutionStatus() { 523 ID retVal = this.getTypedField(11, 0); 524 return retVal; 525 } 526 527 /** 528 * Returns 529 * RXD-11: "Substitution Status" - creates it if necessary 530 */ 531 public ID getRxd11_SubstitutionStatus() { 532 ID retVal = this.getTypedField(11, 0); 533 return retVal; 534 } 535 536 537 538 /** 539 * Returns 540 * RXD-12: "Total Daily Dose" - creates it if necessary 541 */ 542 public CQ getTotalDailyDose() { 543 CQ retVal = this.getTypedField(12, 0); 544 return retVal; 545 } 546 547 /** 548 * Returns 549 * RXD-12: "Total Daily Dose" - creates it if necessary 550 */ 551 public CQ getRxd12_TotalDailyDose() { 552 CQ retVal = this.getTypedField(12, 0); 553 return retVal; 554 } 555 556 557 558 /** 559 * Returns 560 * RXD-13: "Dispense-to Location" - creates it if necessary 561 */ 562 public LA2 getDispenseToLocation() { 563 LA2 retVal = this.getTypedField(13, 0); 564 return retVal; 565 } 566 567 /** 568 * Returns 569 * RXD-13: "Dispense-to Location" - creates it if necessary 570 */ 571 public LA2 getRxd13_DispenseToLocation() { 572 LA2 retVal = this.getTypedField(13, 0); 573 return retVal; 574 } 575 576 577 578 /** 579 * Returns 580 * RXD-14: "Needs Human Review" - creates it if necessary 581 */ 582 public ID getNeedsHumanReview() { 583 ID retVal = this.getTypedField(14, 0); 584 return retVal; 585 } 586 587 /** 588 * Returns 589 * RXD-14: "Needs Human Review" - creates it if necessary 590 */ 591 public ID getRxd14_NeedsHumanReview() { 592 ID retVal = this.getTypedField(14, 0); 593 return retVal; 594 } 595 596 597 /** 598 * Returns all repetitions of Pharmacy/Treatment Supplier's Special Dispensing Instructions (RXD-15). 599 */ 600 public CE[] getPharmacyTreatmentSupplierSSpecialDispensingInstructions() { 601 CE[] retVal = this.getTypedField(15, new CE[0]); 602 return retVal; 603 } 604 605 606 /** 607 * Returns all repetitions of Pharmacy/Treatment Supplier's Special Dispensing Instructions (RXD-15). 608 */ 609 public CE[] getRxd15_PharmacyTreatmentSupplierSSpecialDispensingInstructions() { 610 CE[] retVal = this.getTypedField(15, new CE[0]); 611 return retVal; 612 } 613 614 615 /** 616 * Returns a count of the current number of repetitions of Pharmacy/Treatment Supplier's Special Dispensing Instructions (RXD-15). 617 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 618 * it will return zero. 619 */ 620 public int getPharmacyTreatmentSupplierSSpecialDispensingInstructionsReps() { 621 return this.getReps(15); 622 } 623 624 625 /** 626 * Returns a specific repetition of 627 * RXD-15: "Pharmacy/Treatment Supplier's Special Dispensing Instructions" - creates it if necessary 628 * 629 * @param rep The repetition index (0-indexed) 630 */ 631 public CE getPharmacyTreatmentSupplierSSpecialDispensingInstructions(int rep) { 632 CE retVal = this.getTypedField(15, rep); 633 return retVal; 634 } 635 636 /** 637 * Returns a specific repetition of 638 * RXD-15: "Pharmacy/Treatment Supplier's Special Dispensing Instructions" - creates it if necessary 639 * 640 * @param rep The repetition index (0-indexed) 641 */ 642 public CE getRxd15_PharmacyTreatmentSupplierSSpecialDispensingInstructions(int rep) { 643 CE retVal = this.getTypedField(15, rep); 644 return retVal; 645 } 646 647 /** 648 * Returns a count of the current number of repetitions of Pharmacy/Treatment Supplier's Special Dispensing Instructions (RXD-15). 649 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 650 * it will return zero. 651 */ 652 public int getRxd15_PharmacyTreatmentSupplierSSpecialDispensingInstructionsReps() { 653 return this.getReps(15); 654 } 655 656 657 /** 658 * Inserts a repetition of 659 * RXD-15: "Pharmacy/Treatment Supplier's Special Dispensing Instructions" at a specific index 660 * 661 * @param rep The repetition index (0-indexed) 662 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 663 */ 664 public CE insertPharmacyTreatmentSupplierSSpecialDispensingInstructions(int rep) throws HL7Exception { 665 return (CE) super.insertRepetition(15, rep); 666 } 667 668 669 /** 670 * Inserts a repetition of 671 * RXD-15: "Pharmacy/Treatment Supplier's Special Dispensing Instructions" at a specific index 672 * 673 * @param rep The repetition index (0-indexed) 674 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 675 */ 676 public CE insertRxd15_PharmacyTreatmentSupplierSSpecialDispensingInstructions(int rep) throws HL7Exception { 677 return (CE) super.insertRepetition(15, rep); 678 } 679 680 681 /** 682 * Removes a repetition of 683 * RXD-15: "Pharmacy/Treatment Supplier's Special Dispensing Instructions" at a specific index 684 * 685 * @param rep The repetition index (0-indexed) 686 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 687 */ 688 public CE removePharmacyTreatmentSupplierSSpecialDispensingInstructions(int rep) throws HL7Exception { 689 return (CE) super.removeRepetition(15, rep); 690 } 691 692 693 /** 694 * Removes a repetition of 695 * RXD-15: "Pharmacy/Treatment Supplier's Special Dispensing Instructions" at a specific index 696 * 697 * @param rep The repetition index (0-indexed) 698 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 699 */ 700 public CE removeRxd15_PharmacyTreatmentSupplierSSpecialDispensingInstructions(int rep) throws HL7Exception { 701 return (CE) super.removeRepetition(15, rep); 702 } 703 704 705 706 707 /** 708 * Returns 709 * RXD-16: "Actual Strength" - creates it if necessary 710 */ 711 public NM getActualStrength() { 712 NM retVal = this.getTypedField(16, 0); 713 return retVal; 714 } 715 716 /** 717 * Returns 718 * RXD-16: "Actual Strength" - creates it if necessary 719 */ 720 public NM getRxd16_ActualStrength() { 721 NM retVal = this.getTypedField(16, 0); 722 return retVal; 723 } 724 725 726 727 /** 728 * Returns 729 * RXD-17: "Actual Strength Unit" - creates it if necessary 730 */ 731 public CE getActualStrengthUnit() { 732 CE retVal = this.getTypedField(17, 0); 733 return retVal; 734 } 735 736 /** 737 * Returns 738 * RXD-17: "Actual Strength Unit" - creates it if necessary 739 */ 740 public CE getRxd17_ActualStrengthUnit() { 741 CE retVal = this.getTypedField(17, 0); 742 return retVal; 743 } 744 745 746 /** 747 * Returns all repetitions of Substance Lot Number (RXD-18). 748 */ 749 public ST[] getSubstanceLotNumber() { 750 ST[] retVal = this.getTypedField(18, new ST[0]); 751 return retVal; 752 } 753 754 755 /** 756 * Returns all repetitions of Substance Lot Number (RXD-18). 757 */ 758 public ST[] getRxd18_SubstanceLotNumber() { 759 ST[] retVal = this.getTypedField(18, new ST[0]); 760 return retVal; 761 } 762 763 764 /** 765 * Returns a count of the current number of repetitions of Substance Lot Number (RXD-18). 766 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 767 * it will return zero. 768 */ 769 public int getSubstanceLotNumberReps() { 770 return this.getReps(18); 771 } 772 773 774 /** 775 * Returns a specific repetition of 776 * RXD-18: "Substance Lot Number" - creates it if necessary 777 * 778 * @param rep The repetition index (0-indexed) 779 */ 780 public ST getSubstanceLotNumber(int rep) { 781 ST retVal = this.getTypedField(18, rep); 782 return retVal; 783 } 784 785 /** 786 * Returns a specific repetition of 787 * RXD-18: "Substance Lot Number" - creates it if necessary 788 * 789 * @param rep The repetition index (0-indexed) 790 */ 791 public ST getRxd18_SubstanceLotNumber(int rep) { 792 ST retVal = this.getTypedField(18, rep); 793 return retVal; 794 } 795 796 /** 797 * Returns a count of the current number of repetitions of Substance Lot Number (RXD-18). 798 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 799 * it will return zero. 800 */ 801 public int getRxd18_SubstanceLotNumberReps() { 802 return this.getReps(18); 803 } 804 805 806 /** 807 * Inserts a repetition of 808 * RXD-18: "Substance Lot Number" at a specific index 809 * 810 * @param rep The repetition index (0-indexed) 811 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 812 */ 813 public ST insertSubstanceLotNumber(int rep) throws HL7Exception { 814 return (ST) super.insertRepetition(18, rep); 815 } 816 817 818 /** 819 * Inserts a repetition of 820 * RXD-18: "Substance Lot Number" at a specific index 821 * 822 * @param rep The repetition index (0-indexed) 823 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 824 */ 825 public ST insertRxd18_SubstanceLotNumber(int rep) throws HL7Exception { 826 return (ST) super.insertRepetition(18, rep); 827 } 828 829 830 /** 831 * Removes a repetition of 832 * RXD-18: "Substance Lot Number" at a specific index 833 * 834 * @param rep The repetition index (0-indexed) 835 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 836 */ 837 public ST removeSubstanceLotNumber(int rep) throws HL7Exception { 838 return (ST) super.removeRepetition(18, rep); 839 } 840 841 842 /** 843 * Removes a repetition of 844 * RXD-18: "Substance Lot Number" at a specific index 845 * 846 * @param rep The repetition index (0-indexed) 847 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 848 */ 849 public ST removeRxd18_SubstanceLotNumber(int rep) throws HL7Exception { 850 return (ST) super.removeRepetition(18, rep); 851 } 852 853 854 855 /** 856 * Returns all repetitions of Substance Expiration Date (RXD-19). 857 */ 858 public TS[] getSubstanceExpirationDate() { 859 TS[] retVal = this.getTypedField(19, new TS[0]); 860 return retVal; 861 } 862 863 864 /** 865 * Returns all repetitions of Substance Expiration Date (RXD-19). 866 */ 867 public TS[] getRxd19_SubstanceExpirationDate() { 868 TS[] retVal = this.getTypedField(19, new TS[0]); 869 return retVal; 870 } 871 872 873 /** 874 * Returns a count of the current number of repetitions of Substance Expiration Date (RXD-19). 875 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 876 * it will return zero. 877 */ 878 public int getSubstanceExpirationDateReps() { 879 return this.getReps(19); 880 } 881 882 883 /** 884 * Returns a specific repetition of 885 * RXD-19: "Substance Expiration Date" - creates it if necessary 886 * 887 * @param rep The repetition index (0-indexed) 888 */ 889 public TS getSubstanceExpirationDate(int rep) { 890 TS retVal = this.getTypedField(19, rep); 891 return retVal; 892 } 893 894 /** 895 * Returns a specific repetition of 896 * RXD-19: "Substance Expiration Date" - creates it if necessary 897 * 898 * @param rep The repetition index (0-indexed) 899 */ 900 public TS getRxd19_SubstanceExpirationDate(int rep) { 901 TS retVal = this.getTypedField(19, rep); 902 return retVal; 903 } 904 905 /** 906 * Returns a count of the current number of repetitions of Substance Expiration Date (RXD-19). 907 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 908 * it will return zero. 909 */ 910 public int getRxd19_SubstanceExpirationDateReps() { 911 return this.getReps(19); 912 } 913 914 915 /** 916 * Inserts a repetition of 917 * RXD-19: "Substance Expiration Date" at a specific index 918 * 919 * @param rep The repetition index (0-indexed) 920 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 921 */ 922 public TS insertSubstanceExpirationDate(int rep) throws HL7Exception { 923 return (TS) super.insertRepetition(19, rep); 924 } 925 926 927 /** 928 * Inserts a repetition of 929 * RXD-19: "Substance Expiration Date" at a specific index 930 * 931 * @param rep The repetition index (0-indexed) 932 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 933 */ 934 public TS insertRxd19_SubstanceExpirationDate(int rep) throws HL7Exception { 935 return (TS) super.insertRepetition(19, rep); 936 } 937 938 939 /** 940 * Removes a repetition of 941 * RXD-19: "Substance Expiration Date" at a specific index 942 * 943 * @param rep The repetition index (0-indexed) 944 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 945 */ 946 public TS removeSubstanceExpirationDate(int rep) throws HL7Exception { 947 return (TS) super.removeRepetition(19, rep); 948 } 949 950 951 /** 952 * Removes a repetition of 953 * RXD-19: "Substance Expiration Date" at a specific index 954 * 955 * @param rep The repetition index (0-indexed) 956 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 957 */ 958 public TS removeRxd19_SubstanceExpirationDate(int rep) throws HL7Exception { 959 return (TS) super.removeRepetition(19, rep); 960 } 961 962 963 964 /** 965 * Returns all repetitions of Substance Manufacturer Name (RXD-20). 966 */ 967 public CE[] getSubstanceManufacturerName() { 968 CE[] retVal = this.getTypedField(20, new CE[0]); 969 return retVal; 970 } 971 972 973 /** 974 * Returns all repetitions of Substance Manufacturer Name (RXD-20). 975 */ 976 public CE[] getRxd20_SubstanceManufacturerName() { 977 CE[] retVal = this.getTypedField(20, new CE[0]); 978 return retVal; 979 } 980 981 982 /** 983 * Returns a count of the current number of repetitions of Substance Manufacturer Name (RXD-20). 984 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 985 * it will return zero. 986 */ 987 public int getSubstanceManufacturerNameReps() { 988 return this.getReps(20); 989 } 990 991 992 /** 993 * Returns a specific repetition of 994 * RXD-20: "Substance Manufacturer Name" - creates it if necessary 995 * 996 * @param rep The repetition index (0-indexed) 997 */ 998 public CE getSubstanceManufacturerName(int rep) { 999 CE retVal = this.getTypedField(20, rep); 1000 return retVal; 1001 } 1002 1003 /** 1004 * Returns a specific repetition of 1005 * RXD-20: "Substance Manufacturer Name" - creates it if necessary 1006 * 1007 * @param rep The repetition index (0-indexed) 1008 */ 1009 public CE getRxd20_SubstanceManufacturerName(int rep) { 1010 CE retVal = this.getTypedField(20, rep); 1011 return retVal; 1012 } 1013 1014 /** 1015 * Returns a count of the current number of repetitions of Substance Manufacturer Name (RXD-20). 1016 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1017 * it will return zero. 1018 */ 1019 public int getRxd20_SubstanceManufacturerNameReps() { 1020 return this.getReps(20); 1021 } 1022 1023 1024 /** 1025 * Inserts a repetition of 1026 * RXD-20: "Substance Manufacturer Name" at a specific index 1027 * 1028 * @param rep The repetition index (0-indexed) 1029 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1030 */ 1031 public CE insertSubstanceManufacturerName(int rep) throws HL7Exception { 1032 return (CE) super.insertRepetition(20, rep); 1033 } 1034 1035 1036 /** 1037 * Inserts a repetition of 1038 * RXD-20: "Substance Manufacturer Name" at a specific index 1039 * 1040 * @param rep The repetition index (0-indexed) 1041 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1042 */ 1043 public CE insertRxd20_SubstanceManufacturerName(int rep) throws HL7Exception { 1044 return (CE) super.insertRepetition(20, rep); 1045 } 1046 1047 1048 /** 1049 * Removes a repetition of 1050 * RXD-20: "Substance Manufacturer Name" at a specific index 1051 * 1052 * @param rep The repetition index (0-indexed) 1053 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1054 */ 1055 public CE removeSubstanceManufacturerName(int rep) throws HL7Exception { 1056 return (CE) super.removeRepetition(20, rep); 1057 } 1058 1059 1060 /** 1061 * Removes a repetition of 1062 * RXD-20: "Substance Manufacturer Name" at a specific index 1063 * 1064 * @param rep The repetition index (0-indexed) 1065 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1066 */ 1067 public CE removeRxd20_SubstanceManufacturerName(int rep) throws HL7Exception { 1068 return (CE) super.removeRepetition(20, rep); 1069 } 1070 1071 1072 1073 /** 1074 * Returns all repetitions of Indication (RXD-21). 1075 */ 1076 public CE[] getIndication() { 1077 CE[] retVal = this.getTypedField(21, new CE[0]); 1078 return retVal; 1079 } 1080 1081 1082 /** 1083 * Returns all repetitions of Indication (RXD-21). 1084 */ 1085 public CE[] getRxd21_Indication() { 1086 CE[] retVal = this.getTypedField(21, new CE[0]); 1087 return retVal; 1088 } 1089 1090 1091 /** 1092 * Returns a count of the current number of repetitions of Indication (RXD-21). 1093 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1094 * it will return zero. 1095 */ 1096 public int getIndicationReps() { 1097 return this.getReps(21); 1098 } 1099 1100 1101 /** 1102 * Returns a specific repetition of 1103 * RXD-21: "Indication" - creates it if necessary 1104 * 1105 * @param rep The repetition index (0-indexed) 1106 */ 1107 public CE getIndication(int rep) { 1108 CE retVal = this.getTypedField(21, rep); 1109 return retVal; 1110 } 1111 1112 /** 1113 * Returns a specific repetition of 1114 * RXD-21: "Indication" - creates it if necessary 1115 * 1116 * @param rep The repetition index (0-indexed) 1117 */ 1118 public CE getRxd21_Indication(int rep) { 1119 CE retVal = this.getTypedField(21, rep); 1120 return retVal; 1121 } 1122 1123 /** 1124 * Returns a count of the current number of repetitions of Indication (RXD-21). 1125 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1126 * it will return zero. 1127 */ 1128 public int getRxd21_IndicationReps() { 1129 return this.getReps(21); 1130 } 1131 1132 1133 /** 1134 * Inserts a repetition of 1135 * RXD-21: "Indication" at a specific index 1136 * 1137 * @param rep The repetition index (0-indexed) 1138 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1139 */ 1140 public CE insertIndication(int rep) throws HL7Exception { 1141 return (CE) super.insertRepetition(21, rep); 1142 } 1143 1144 1145 /** 1146 * Inserts a repetition of 1147 * RXD-21: "Indication" at a specific index 1148 * 1149 * @param rep The repetition index (0-indexed) 1150 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1151 */ 1152 public CE insertRxd21_Indication(int rep) throws HL7Exception { 1153 return (CE) super.insertRepetition(21, rep); 1154 } 1155 1156 1157 /** 1158 * Removes a repetition of 1159 * RXD-21: "Indication" at a specific index 1160 * 1161 * @param rep The repetition index (0-indexed) 1162 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1163 */ 1164 public CE removeIndication(int rep) throws HL7Exception { 1165 return (CE) super.removeRepetition(21, rep); 1166 } 1167 1168 1169 /** 1170 * Removes a repetition of 1171 * RXD-21: "Indication" at a specific index 1172 * 1173 * @param rep The repetition index (0-indexed) 1174 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1175 */ 1176 public CE removeRxd21_Indication(int rep) throws HL7Exception { 1177 return (CE) super.removeRepetition(21, rep); 1178 } 1179 1180 1181 1182 1183 /** 1184 * Returns 1185 * RXD-22: "Dispense Package Size" - creates it if necessary 1186 */ 1187 public NM getDispensePackageSize() { 1188 NM retVal = this.getTypedField(22, 0); 1189 return retVal; 1190 } 1191 1192 /** 1193 * Returns 1194 * RXD-22: "Dispense Package Size" - creates it if necessary 1195 */ 1196 public NM getRxd22_DispensePackageSize() { 1197 NM retVal = this.getTypedField(22, 0); 1198 return retVal; 1199 } 1200 1201 1202 1203 /** 1204 * Returns 1205 * RXD-23: "Dispense Package Size Unit" - creates it if necessary 1206 */ 1207 public CE getDispensePackageSizeUnit() { 1208 CE retVal = this.getTypedField(23, 0); 1209 return retVal; 1210 } 1211 1212 /** 1213 * Returns 1214 * RXD-23: "Dispense Package Size Unit" - creates it if necessary 1215 */ 1216 public CE getRxd23_DispensePackageSizeUnit() { 1217 CE retVal = this.getTypedField(23, 0); 1218 return retVal; 1219 } 1220 1221 1222 1223 /** 1224 * Returns 1225 * RXD-24: "Dispense Package Method" - creates it if necessary 1226 */ 1227 public ID getDispensePackageMethod() { 1228 ID retVal = this.getTypedField(24, 0); 1229 return retVal; 1230 } 1231 1232 /** 1233 * Returns 1234 * RXD-24: "Dispense Package Method" - creates it if necessary 1235 */ 1236 public ID getRxd24_DispensePackageMethod() { 1237 ID retVal = this.getTypedField(24, 0); 1238 return retVal; 1239 } 1240 1241 1242 /** 1243 * Returns all repetitions of Supplementary Code (RXD-25). 1244 */ 1245 public CE[] getSupplementaryCode() { 1246 CE[] retVal = this.getTypedField(25, new CE[0]); 1247 return retVal; 1248 } 1249 1250 1251 /** 1252 * Returns all repetitions of Supplementary Code (RXD-25). 1253 */ 1254 public CE[] getRxd25_SupplementaryCode() { 1255 CE[] retVal = this.getTypedField(25, new CE[0]); 1256 return retVal; 1257 } 1258 1259 1260 /** 1261 * Returns a count of the current number of repetitions of Supplementary Code (RXD-25). 1262 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1263 * it will return zero. 1264 */ 1265 public int getSupplementaryCodeReps() { 1266 return this.getReps(25); 1267 } 1268 1269 1270 /** 1271 * Returns a specific repetition of 1272 * RXD-25: "Supplementary Code" - creates it if necessary 1273 * 1274 * @param rep The repetition index (0-indexed) 1275 */ 1276 public CE getSupplementaryCode(int rep) { 1277 CE retVal = this.getTypedField(25, rep); 1278 return retVal; 1279 } 1280 1281 /** 1282 * Returns a specific repetition of 1283 * RXD-25: "Supplementary Code" - creates it if necessary 1284 * 1285 * @param rep The repetition index (0-indexed) 1286 */ 1287 public CE getRxd25_SupplementaryCode(int rep) { 1288 CE retVal = this.getTypedField(25, rep); 1289 return retVal; 1290 } 1291 1292 /** 1293 * Returns a count of the current number of repetitions of Supplementary Code (RXD-25). 1294 * This method does not create a repetition, so if no repetitions have currently been defined or accessed, 1295 * it will return zero. 1296 */ 1297 public int getRxd25_SupplementaryCodeReps() { 1298 return this.getReps(25); 1299 } 1300 1301 1302 /** 1303 * Inserts a repetition of 1304 * RXD-25: "Supplementary Code" at a specific index 1305 * 1306 * @param rep The repetition index (0-indexed) 1307 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1308 */ 1309 public CE insertSupplementaryCode(int rep) throws HL7Exception { 1310 return (CE) super.insertRepetition(25, rep); 1311 } 1312 1313 1314 /** 1315 * Inserts a repetition of 1316 * RXD-25: "Supplementary Code" at a specific index 1317 * 1318 * @param rep The repetition index (0-indexed) 1319 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1320 */ 1321 public CE insertRxd25_SupplementaryCode(int rep) throws HL7Exception { 1322 return (CE) super.insertRepetition(25, rep); 1323 } 1324 1325 1326 /** 1327 * Removes a repetition of 1328 * RXD-25: "Supplementary Code" at a specific index 1329 * 1330 * @param rep The repetition index (0-indexed) 1331 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1332 */ 1333 public CE removeSupplementaryCode(int rep) throws HL7Exception { 1334 return (CE) super.removeRepetition(25, rep); 1335 } 1336 1337 1338 /** 1339 * Removes a repetition of 1340 * RXD-25: "Supplementary Code" at a specific index 1341 * 1342 * @param rep The repetition index (0-indexed) 1343 * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) 1344 */ 1345 public CE removeRxd25_SupplementaryCode(int rep) throws HL7Exception { 1346 return (CE) super.removeRepetition(25, rep); 1347 } 1348 1349 1350 1351 1352 /** 1353 * Returns 1354 * RXD-26: "Initiating Location" - creates it if necessary 1355 */ 1356 public CE getInitiatingLocation() { 1357 CE retVal = this.getTypedField(26, 0); 1358 return retVal; 1359 } 1360 1361 /** 1362 * Returns 1363 * RXD-26: "Initiating Location" - creates it if necessary 1364 */ 1365 public CE getRxd26_InitiatingLocation() { 1366 CE retVal = this.getTypedField(26, 0); 1367 return retVal; 1368 } 1369 1370 1371 1372 /** 1373 * Returns 1374 * RXD-27: "Packaging/Assembly Location" - creates it if necessary 1375 */ 1376 public CE getPackagingAssemblyLocation() { 1377 CE retVal = this.getTypedField(27, 0); 1378 return retVal; 1379 } 1380 1381 /** 1382 * Returns 1383 * RXD-27: "Packaging/Assembly Location" - creates it if necessary 1384 */ 1385 public CE getRxd27_PackagingAssemblyLocation() { 1386 CE retVal = this.getTypedField(27, 0); 1387 return retVal; 1388 } 1389 1390 1391 1392 /** 1393 * Returns 1394 * RXD-28: "Actual Drug Strength Volume" - creates it if necessary 1395 */ 1396 public NM getActualDrugStrengthVolume() { 1397 NM retVal = this.getTypedField(28, 0); 1398 return retVal; 1399 } 1400 1401 /** 1402 * Returns 1403 * RXD-28: "Actual Drug Strength Volume" - creates it if necessary 1404 */ 1405 public NM getRxd28_ActualDrugStrengthVolume() { 1406 NM retVal = this.getTypedField(28, 0); 1407 return retVal; 1408 } 1409 1410 1411 1412 /** 1413 * Returns 1414 * RXD-29: "Actual Drug Strength Volume Units" - creates it if necessary 1415 */ 1416 public CWE getActualDrugStrengthVolumeUnits() { 1417 CWE retVal = this.getTypedField(29, 0); 1418 return retVal; 1419 } 1420 1421 /** 1422 * Returns 1423 * RXD-29: "Actual Drug Strength Volume Units" - creates it if necessary 1424 */ 1425 public CWE getRxd29_ActualDrugStrengthVolumeUnits() { 1426 CWE retVal = this.getTypedField(29, 0); 1427 return retVal; 1428 } 1429 1430 1431 1432 /** 1433 * Returns 1434 * RXD-30: "Dispense to Pharmacy" - creates it if necessary 1435 */ 1436 public CWE getDispenseToPharmacy() { 1437 CWE retVal = this.getTypedField(30, 0); 1438 return retVal; 1439 } 1440 1441 /** 1442 * Returns 1443 * RXD-30: "Dispense to Pharmacy" - creates it if necessary 1444 */ 1445 public CWE getRxd30_DispenseToPharmacy() { 1446 CWE retVal = this.getTypedField(30, 0); 1447 return retVal; 1448 } 1449 1450 1451 1452 /** 1453 * Returns 1454 * RXD-31: "Dispense to Pharmacy Address" - creates it if necessary 1455 */ 1456 public XAD getDispenseToPharmacyAddress() { 1457 XAD retVal = this.getTypedField(31, 0); 1458 return retVal; 1459 } 1460 1461 /** 1462 * Returns 1463 * RXD-31: "Dispense to Pharmacy Address" - creates it if necessary 1464 */ 1465 public XAD getRxd31_DispenseToPharmacyAddress() { 1466 XAD retVal = this.getTypedField(31, 0); 1467 return retVal; 1468 } 1469 1470 1471 1472 /** 1473 * Returns 1474 * RXD-32: "Pharmacy Order Type" - creates it if necessary 1475 */ 1476 public ID getPharmacyOrderType() { 1477 ID retVal = this.getTypedField(32, 0); 1478 return retVal; 1479 } 1480 1481 /** 1482 * Returns 1483 * RXD-32: "Pharmacy Order Type" - creates it if necessary 1484 */ 1485 public ID getRxd32_PharmacyOrderType() { 1486 ID retVal = this.getTypedField(32, 0); 1487 return retVal; 1488 } 1489 1490 1491 1492 /** 1493 * Returns 1494 * RXD-33: "Dispense Type" - creates it if necessary 1495 */ 1496 public CWE getDispenseType() { 1497 CWE retVal = this.getTypedField(33, 0); 1498 return retVal; 1499 } 1500 1501 /** 1502 * Returns 1503 * RXD-33: "Dispense Type" - creates it if necessary 1504 */ 1505 public CWE getRxd33_DispenseType() { 1506 CWE retVal = this.getTypedField(33, 0); 1507 return retVal; 1508 } 1509 1510 1511 1512 1513 1514 /** {@inheritDoc} */ 1515 protected Type createNewTypeWithoutReflection(int field) { 1516 switch (field) { 1517 case 0: return new NM(getMessage()); 1518 case 1: return new CE(getMessage()); 1519 case 2: return new TS(getMessage()); 1520 case 3: return new NM(getMessage()); 1521 case 4: return new CE(getMessage()); 1522 case 5: return new CE(getMessage()); 1523 case 6: return new ST(getMessage()); 1524 case 7: return new NM(getMessage()); 1525 case 8: return new ST(getMessage()); 1526 case 9: return new XCN(getMessage()); 1527 case 10: return new ID(getMessage(), new Integer( 167 )); 1528 case 11: return new CQ(getMessage()); 1529 case 12: return new LA2(getMessage()); 1530 case 13: return new ID(getMessage(), new Integer( 136 )); 1531 case 14: return new CE(getMessage()); 1532 case 15: return new NM(getMessage()); 1533 case 16: return new CE(getMessage()); 1534 case 17: return new ST(getMessage()); 1535 case 18: return new TS(getMessage()); 1536 case 19: return new CE(getMessage()); 1537 case 20: return new CE(getMessage()); 1538 case 21: return new NM(getMessage()); 1539 case 22: return new CE(getMessage()); 1540 case 23: return new ID(getMessage(), new Integer( 321 )); 1541 case 24: return new CE(getMessage()); 1542 case 25: return new CE(getMessage()); 1543 case 26: return new CE(getMessage()); 1544 case 27: return new NM(getMessage()); 1545 case 28: return new CWE(getMessage()); 1546 case 29: return new CWE(getMessage()); 1547 case 30: return new XAD(getMessage()); 1548 case 31: return new ID(getMessage(), new Integer( 480 )); 1549 case 32: return new CWE(getMessage()); 1550 default: return null; 1551 } 1552 } 1553 1554 1555} 1556