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