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