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