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