Source code

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/**
049 *<p>Represents an HL7 RXA message segment (Pharmacy/Treatment Administration). 
050 * This segment has the following fields:</p>
051 * <ul>
052     * <li>RXA-1: Give Sub-ID Counter (NM) <b> </b>
053     * <li>RXA-2: Administration Sub-ID Counter (NM) <b> </b>
054     * <li>RXA-3: Date/Time Start of Administration (TS) <b> </b>
055     * <li>RXA-4: Date/Time End of Administration (TS) <b> </b>
056     * <li>RXA-5: Administered Code (CE) <b> </b>
057     * <li>RXA-6: Administered Amount (NM) <b> </b>
058     * <li>RXA-7: Administered Units (CE) <b>optional </b>
059     * <li>RXA-8: Administered Dosage Form (CE) <b>optional </b>
060     * <li>RXA-9: Administration Notes (CE) <b>optional repeating</b>
061     * <li>RXA-10: Administering Provider (XCN) <b>optional repeating</b>
062     * <li>RXA-11: Administered-at Location (LA2) <b>optional </b>
063     * <li>RXA-12: Administered Per (Time Unit) (ST) <b>optional </b>
064     * <li>RXA-13: Administered Strength (NM) <b>optional </b>
065     * <li>RXA-14: Administered Strength Units (CE) <b>optional </b>
066     * <li>RXA-15: Substance Lot Number (ST) <b>optional repeating</b>
067     * <li>RXA-16: Substance Expiration Date (TS) <b>optional repeating</b>
068     * <li>RXA-17: Substance Manufacturer Name (CE) <b>optional repeating</b>
069     * <li>RXA-18: Substance/Treatment Refusal Reason (CE) <b>optional repeating</b>
070     * <li>RXA-19: Indication (CE) <b>optional repeating</b>
071     * <li>RXA-20: Completion Status (ID) <b>optional </b>
072     * <li>RXA-21: Action Code - RXA (ID) <b>optional </b>
073     * <li>RXA-22: System Entry Date/Time (TS) <b>optional </b>
074     * <li>RXA-23: Administered Drug Strength Volume (NM) <b>optional </b>
075     * <li>RXA-24: Administered Drug Strength Volume Units (CWE) <b>optional </b>
076     * <li>RXA-25: Administered Barcode Identifier (CWE) <b>optional </b>
077     * <li>RXA-26: Pharmacy Order Type (ID) <b>optional </b>
078 * </ul>
079 */
080@SuppressWarnings("unused")
081public class RXA extends AbstractSegment {
082
083    /** 
084     * Creates a new RXA segment
085     */
086    public RXA(Group parent, ModelClassFactory factory) {
087       super(parent, factory);
088       init(factory);
089    }
090
091    private void init(ModelClassFactory factory) {
092       try {
093                                  this.add(NM.class, true, 1, 4, new Object[]{ getMessage() }, "Give Sub-ID Counter");
094                                  this.add(NM.class, true, 1, 4, new Object[]{ getMessage() }, "Administration Sub-ID Counter");
095                                  this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Date/Time Start of Administration");
096                                  this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Date/Time End of Administration");
097                                  this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Administered Code");
098                                  this.add(NM.class, true, 1, 20, new Object[]{ getMessage() }, "Administered Amount");
099                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Administered Units");
100                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Administered Dosage Form");
101                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Administration Notes");
102                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Administering Provider");
103                                  this.add(LA2.class, false, 1, 200, new Object[]{ getMessage() }, "Administered-at Location");
104                                  this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Administered Per (Time Unit)");
105                                  this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Administered Strength");
106                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Administered Strength Units");
107                                  this.add(ST.class, false, 0, 20, new Object[]{ getMessage() }, "Substance Lot Number");
108                                  this.add(TS.class, false, 0, 26, new Object[]{ getMessage() }, "Substance Expiration Date");
109                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Substance Manufacturer Name");
110                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Substance/Treatment Refusal Reason");
111                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Indication");
112                                              this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(322) }, "Completion Status");
113                                              this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(323) }, "Action Code - RXA");
114                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "System Entry Date/Time");
115                                  this.add(NM.class, false, 1, 5, new Object[]{ getMessage() }, "Administered Drug Strength Volume");
116                                  this.add(CWE.class, false, 1, 250, new Object[]{ getMessage() }, "Administered Drug Strength Volume Units");
117                                  this.add(CWE.class, false, 1, 60, new Object[]{ getMessage() }, "Administered Barcode Identifier");
118                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(480) }, "Pharmacy Order Type");
119       } catch(HL7Exception e) {
120          log.error("Unexpected error creating RXA - this is probably a bug in the source code generator.", e);
121       }
122    }
123
124
125
126    /**
127     * Returns
128     * RXA-1: "Give Sub-ID Counter" - creates it if necessary
129     */
130    public NM getGiveSubIDCounter() { 
131                NM retVal = this.getTypedField(1, 0);
132                return retVal;
133    }
134    
135    /**
136     * Returns
137     * RXA-1: "Give Sub-ID Counter" - creates it if necessary
138     */
139    public NM getRxa1_GiveSubIDCounter() { 
140                NM retVal = this.getTypedField(1, 0);
141                return retVal;
142    }
143
144
145
146    /**
147     * Returns
148     * RXA-2: "Administration Sub-ID Counter" - creates it if necessary
149     */
150    public NM getAdministrationSubIDCounter() { 
151                NM retVal = this.getTypedField(2, 0);
152                return retVal;
153    }
154    
155    /**
156     * Returns
157     * RXA-2: "Administration Sub-ID Counter" - creates it if necessary
158     */
159    public NM getRxa2_AdministrationSubIDCounter() { 
160                NM retVal = this.getTypedField(2, 0);
161                return retVal;
162    }
163
164
165
166    /**
167     * Returns
168     * RXA-3: "Date/Time Start of Administration" - creates it if necessary
169     */
170    public TS getDateTimeStartOfAdministration() { 
171                TS retVal = this.getTypedField(3, 0);
172                return retVal;
173    }
174    
175    /**
176     * Returns
177     * RXA-3: "Date/Time Start of Administration" - creates it if necessary
178     */
179    public TS getRxa3_DateTimeStartOfAdministration() { 
180                TS retVal = this.getTypedField(3, 0);
181                return retVal;
182    }
183
184
185
186    /**
187     * Returns
188     * RXA-4: "Date/Time End of Administration" - creates it if necessary
189     */
190    public TS getDateTimeEndOfAdministration() { 
191                TS retVal = this.getTypedField(4, 0);
192                return retVal;
193    }
194    
195    /**
196     * Returns
197     * RXA-4: "Date/Time End of Administration" - creates it if necessary
198     */
199    public TS getRxa4_DateTimeEndOfAdministration() { 
200                TS retVal = this.getTypedField(4, 0);
201                return retVal;
202    }
203
204
205
206    /**
207     * Returns
208     * RXA-5: "Administered Code" - creates it if necessary
209     */
210    public CE getAdministeredCode() { 
211                CE retVal = this.getTypedField(5, 0);
212                return retVal;
213    }
214    
215    /**
216     * Returns
217     * RXA-5: "Administered Code" - creates it if necessary
218     */
219    public CE getRxa5_AdministeredCode() { 
220                CE retVal = this.getTypedField(5, 0);
221                return retVal;
222    }
223
224
225
226    /**
227     * Returns
228     * RXA-6: "Administered Amount" - creates it if necessary
229     */
230    public NM getAdministeredAmount() { 
231                NM retVal = this.getTypedField(6, 0);
232                return retVal;
233    }
234    
235    /**
236     * Returns
237     * RXA-6: "Administered Amount" - creates it if necessary
238     */
239    public NM getRxa6_AdministeredAmount() { 
240                NM retVal = this.getTypedField(6, 0);
241                return retVal;
242    }
243
244
245
246    /**
247     * Returns
248     * RXA-7: "Administered Units" - creates it if necessary
249     */
250    public CE getAdministeredUnits() { 
251                CE retVal = this.getTypedField(7, 0);
252                return retVal;
253    }
254    
255    /**
256     * Returns
257     * RXA-7: "Administered Units" - creates it if necessary
258     */
259    public CE getRxa7_AdministeredUnits() { 
260                CE retVal = this.getTypedField(7, 0);
261                return retVal;
262    }
263
264
265
266    /**
267     * Returns
268     * RXA-8: "Administered Dosage Form" - creates it if necessary
269     */
270    public CE getAdministeredDosageForm() { 
271                CE retVal = this.getTypedField(8, 0);
272                return retVal;
273    }
274    
275    /**
276     * Returns
277     * RXA-8: "Administered Dosage Form" - creates it if necessary
278     */
279    public CE getRxa8_AdministeredDosageForm() { 
280                CE retVal = this.getTypedField(8, 0);
281                return retVal;
282    }
283
284
285    /**
286     * Returns all repetitions of Administration Notes (RXA-9).
287     */
288    public CE[] getAdministrationNotes() {
289        CE[] retVal = this.getTypedField(9, new CE[0]);
290        return retVal;
291    }
292
293
294    /**
295     * Returns all repetitions of Administration Notes (RXA-9).
296     */
297    public CE[] getRxa9_AdministrationNotes() {
298        CE[] retVal = this.getTypedField(9, new CE[0]);
299        return retVal;
300    }
301
302
303    /**
304     * Returns a count of the current number of repetitions of Administration Notes (RXA-9).
305     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
306     * it will return zero.
307     */
308    public int getAdministrationNotesReps() {
309        return this.getReps(9);
310    }
311
312
313    /**
314     * Returns a specific repetition of
315     * RXA-9: "Administration Notes" - creates it if necessary
316     *
317     * @param rep The repetition index (0-indexed)
318     */
319    public CE getAdministrationNotes(int rep) { 
320                CE retVal = this.getTypedField(9, rep);
321                return retVal;
322    }
323
324    /**
325     * Returns a specific repetition of
326     * RXA-9: "Administration Notes" - creates it if necessary
327     *
328     * @param rep The repetition index (0-indexed)
329     */
330    public CE getRxa9_AdministrationNotes(int rep) { 
331                CE retVal = this.getTypedField(9, rep);
332                return retVal;
333    }
334
335    /**
336     * Returns a count of the current number of repetitions of Administration Notes (RXA-9).
337     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
338     * it will return zero.
339     */
340    public int getRxa9_AdministrationNotesReps() {
341        return this.getReps(9);
342    }
343
344
345    /**
346     * Inserts a repetition of
347     * RXA-9: "Administration Notes" at a specific index
348     *
349     * @param rep The repetition index (0-indexed)
350     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
351     */
352    public CE insertAdministrationNotes(int rep) throws HL7Exception { 
353        return (CE) super.insertRepetition(9, rep);
354    }
355
356
357    /**
358     * Inserts a repetition of
359     * RXA-9: "Administration Notes" at a specific index
360     *
361     * @param rep The repetition index (0-indexed)
362     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
363     */
364    public CE insertRxa9_AdministrationNotes(int rep) throws HL7Exception { 
365        return (CE) super.insertRepetition(9, rep);
366    }
367
368
369    /**
370     * Removes a repetition of
371     * RXA-9: "Administration Notes" at a specific index
372     *
373     * @param rep The repetition index (0-indexed)
374     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
375     */
376    public CE removeAdministrationNotes(int rep) throws HL7Exception { 
377        return (CE) super.removeRepetition(9, rep);
378    }
379
380
381    /**
382     * Removes a repetition of
383     * RXA-9: "Administration Notes" at a specific index
384     *
385     * @param rep The repetition index (0-indexed)
386     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
387     */
388    public CE removeRxa9_AdministrationNotes(int rep) throws HL7Exception { 
389        return (CE) super.removeRepetition(9, rep);
390    }
391
392
393
394    /**
395     * Returns all repetitions of Administering Provider (RXA-10).
396     */
397    public XCN[] getAdministeringProvider() {
398        XCN[] retVal = this.getTypedField(10, new XCN[0]);
399        return retVal;
400    }
401
402
403    /**
404     * Returns all repetitions of Administering Provider (RXA-10).
405     */
406    public XCN[] getRxa10_AdministeringProvider() {
407        XCN[] retVal = this.getTypedField(10, new XCN[0]);
408        return retVal;
409    }
410
411
412    /**
413     * Returns a count of the current number of repetitions of Administering Provider (RXA-10).
414     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
415     * it will return zero.
416     */
417    public int getAdministeringProviderReps() {
418        return this.getReps(10);
419    }
420
421
422    /**
423     * Returns a specific repetition of
424     * RXA-10: "Administering Provider" - creates it if necessary
425     *
426     * @param rep The repetition index (0-indexed)
427     */
428    public XCN getAdministeringProvider(int rep) { 
429                XCN retVal = this.getTypedField(10, rep);
430                return retVal;
431    }
432
433    /**
434     * Returns a specific repetition of
435     * RXA-10: "Administering Provider" - creates it if necessary
436     *
437     * @param rep The repetition index (0-indexed)
438     */
439    public XCN getRxa10_AdministeringProvider(int rep) { 
440                XCN retVal = this.getTypedField(10, rep);
441                return retVal;
442    }
443
444    /**
445     * Returns a count of the current number of repetitions of Administering Provider (RXA-10).
446     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
447     * it will return zero.
448     */
449    public int getRxa10_AdministeringProviderReps() {
450        return this.getReps(10);
451    }
452
453
454    /**
455     * Inserts a repetition of
456     * RXA-10: "Administering Provider" at a specific index
457     *
458     * @param rep The repetition index (0-indexed)
459     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
460     */
461    public XCN insertAdministeringProvider(int rep) throws HL7Exception { 
462        return (XCN) super.insertRepetition(10, rep);
463    }
464
465
466    /**
467     * Inserts a repetition of
468     * RXA-10: "Administering Provider" at a specific index
469     *
470     * @param rep The repetition index (0-indexed)
471     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
472     */
473    public XCN insertRxa10_AdministeringProvider(int rep) throws HL7Exception { 
474        return (XCN) super.insertRepetition(10, rep);
475    }
476
477
478    /**
479     * Removes a repetition of
480     * RXA-10: "Administering Provider" at a specific index
481     *
482     * @param rep The repetition index (0-indexed)
483     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
484     */
485    public XCN removeAdministeringProvider(int rep) throws HL7Exception { 
486        return (XCN) super.removeRepetition(10, rep);
487    }
488
489
490    /**
491     * Removes a repetition of
492     * RXA-10: "Administering Provider" at a specific index
493     *
494     * @param rep The repetition index (0-indexed)
495     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
496     */
497    public XCN removeRxa10_AdministeringProvider(int rep) throws HL7Exception { 
498        return (XCN) super.removeRepetition(10, rep);
499    }
500
501
502
503
504    /**
505     * Returns
506     * RXA-11: "Administered-at Location" - creates it if necessary
507     */
508    public LA2 getAdministeredAtLocation() { 
509                LA2 retVal = this.getTypedField(11, 0);
510                return retVal;
511    }
512    
513    /**
514     * Returns
515     * RXA-11: "Administered-at Location" - creates it if necessary
516     */
517    public LA2 getRxa11_AdministeredAtLocation() { 
518                LA2 retVal = this.getTypedField(11, 0);
519                return retVal;
520    }
521
522
523
524    /**
525     * Returns
526     * RXA-12: "Administered Per (Time Unit)" - creates it if necessary
527     */
528    public ST getAdministeredPerTimeUnit() { 
529                ST retVal = this.getTypedField(12, 0);
530                return retVal;
531    }
532    
533    /**
534     * Returns
535     * RXA-12: "Administered Per (Time Unit)" - creates it if necessary
536     */
537    public ST getRxa12_AdministeredPerTimeUnit() { 
538                ST retVal = this.getTypedField(12, 0);
539                return retVal;
540    }
541
542
543
544    /**
545     * Returns
546     * RXA-13: "Administered Strength" - creates it if necessary
547     */
548    public NM getAdministeredStrength() { 
549                NM retVal = this.getTypedField(13, 0);
550                return retVal;
551    }
552    
553    /**
554     * Returns
555     * RXA-13: "Administered Strength" - creates it if necessary
556     */
557    public NM getRxa13_AdministeredStrength() { 
558                NM retVal = this.getTypedField(13, 0);
559                return retVal;
560    }
561
562
563
564    /**
565     * Returns
566     * RXA-14: "Administered Strength Units" - creates it if necessary
567     */
568    public CE getAdministeredStrengthUnits() { 
569                CE retVal = this.getTypedField(14, 0);
570                return retVal;
571    }
572    
573    /**
574     * Returns
575     * RXA-14: "Administered Strength Units" - creates it if necessary
576     */
577    public CE getRxa14_AdministeredStrengthUnits() { 
578                CE retVal = this.getTypedField(14, 0);
579                return retVal;
580    }
581
582
583    /**
584     * Returns all repetitions of Substance Lot Number (RXA-15).
585     */
586    public ST[] getSubstanceLotNumber() {
587        ST[] retVal = this.getTypedField(15, new ST[0]);
588        return retVal;
589    }
590
591
592    /**
593     * Returns all repetitions of Substance Lot Number (RXA-15).
594     */
595    public ST[] getRxa15_SubstanceLotNumber() {
596        ST[] retVal = this.getTypedField(15, new ST[0]);
597        return retVal;
598    }
599
600
601    /**
602     * Returns a count of the current number of repetitions of Substance Lot Number (RXA-15).
603     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
604     * it will return zero.
605     */
606    public int getSubstanceLotNumberReps() {
607        return this.getReps(15);
608    }
609
610
611    /**
612     * Returns a specific repetition of
613     * RXA-15: "Substance Lot Number" - creates it if necessary
614     *
615     * @param rep The repetition index (0-indexed)
616     */
617    public ST getSubstanceLotNumber(int rep) { 
618                ST retVal = this.getTypedField(15, rep);
619                return retVal;
620    }
621
622    /**
623     * Returns a specific repetition of
624     * RXA-15: "Substance Lot Number" - creates it if necessary
625     *
626     * @param rep The repetition index (0-indexed)
627     */
628    public ST getRxa15_SubstanceLotNumber(int rep) { 
629                ST retVal = this.getTypedField(15, rep);
630                return retVal;
631    }
632
633    /**
634     * Returns a count of the current number of repetitions of Substance Lot Number (RXA-15).
635     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
636     * it will return zero.
637     */
638    public int getRxa15_SubstanceLotNumberReps() {
639        return this.getReps(15);
640    }
641
642
643    /**
644     * Inserts a repetition of
645     * RXA-15: "Substance Lot Number" at a specific index
646     *
647     * @param rep The repetition index (0-indexed)
648     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
649     */
650    public ST insertSubstanceLotNumber(int rep) throws HL7Exception { 
651        return (ST) super.insertRepetition(15, rep);
652    }
653
654
655    /**
656     * Inserts a repetition of
657     * RXA-15: "Substance Lot Number" at a specific index
658     *
659     * @param rep The repetition index (0-indexed)
660     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
661     */
662    public ST insertRxa15_SubstanceLotNumber(int rep) throws HL7Exception { 
663        return (ST) super.insertRepetition(15, rep);
664    }
665
666
667    /**
668     * Removes a repetition of
669     * RXA-15: "Substance Lot Number" at a specific index
670     *
671     * @param rep The repetition index (0-indexed)
672     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
673     */
674    public ST removeSubstanceLotNumber(int rep) throws HL7Exception { 
675        return (ST) super.removeRepetition(15, rep);
676    }
677
678
679    /**
680     * Removes a repetition of
681     * RXA-15: "Substance Lot Number" at a specific index
682     *
683     * @param rep The repetition index (0-indexed)
684     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
685     */
686    public ST removeRxa15_SubstanceLotNumber(int rep) throws HL7Exception { 
687        return (ST) super.removeRepetition(15, rep);
688    }
689
690
691
692    /**
693     * Returns all repetitions of Substance Expiration Date (RXA-16).
694     */
695    public TS[] getSubstanceExpirationDate() {
696        TS[] retVal = this.getTypedField(16, new TS[0]);
697        return retVal;
698    }
699
700
701    /**
702     * Returns all repetitions of Substance Expiration Date (RXA-16).
703     */
704    public TS[] getRxa16_SubstanceExpirationDate() {
705        TS[] retVal = this.getTypedField(16, new TS[0]);
706        return retVal;
707    }
708
709
710    /**
711     * Returns a count of the current number of repetitions of Substance Expiration Date (RXA-16).
712     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
713     * it will return zero.
714     */
715    public int getSubstanceExpirationDateReps() {
716        return this.getReps(16);
717    }
718
719
720    /**
721     * Returns a specific repetition of
722     * RXA-16: "Substance Expiration Date" - creates it if necessary
723     *
724     * @param rep The repetition index (0-indexed)
725     */
726    public TS getSubstanceExpirationDate(int rep) { 
727                TS retVal = this.getTypedField(16, rep);
728                return retVal;
729    }
730
731    /**
732     * Returns a specific repetition of
733     * RXA-16: "Substance Expiration Date" - creates it if necessary
734     *
735     * @param rep The repetition index (0-indexed)
736     */
737    public TS getRxa16_SubstanceExpirationDate(int rep) { 
738                TS retVal = this.getTypedField(16, rep);
739                return retVal;
740    }
741
742    /**
743     * Returns a count of the current number of repetitions of Substance Expiration Date (RXA-16).
744     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
745     * it will return zero.
746     */
747    public int getRxa16_SubstanceExpirationDateReps() {
748        return this.getReps(16);
749    }
750
751
752    /**
753     * Inserts a repetition of
754     * RXA-16: "Substance Expiration Date" at a specific index
755     *
756     * @param rep The repetition index (0-indexed)
757     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
758     */
759    public TS insertSubstanceExpirationDate(int rep) throws HL7Exception { 
760        return (TS) super.insertRepetition(16, rep);
761    }
762
763
764    /**
765     * Inserts a repetition of
766     * RXA-16: "Substance Expiration Date" at a specific index
767     *
768     * @param rep The repetition index (0-indexed)
769     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
770     */
771    public TS insertRxa16_SubstanceExpirationDate(int rep) throws HL7Exception { 
772        return (TS) super.insertRepetition(16, rep);
773    }
774
775
776    /**
777     * Removes a repetition of
778     * RXA-16: "Substance Expiration Date" at a specific index
779     *
780     * @param rep The repetition index (0-indexed)
781     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
782     */
783    public TS removeSubstanceExpirationDate(int rep) throws HL7Exception { 
784        return (TS) super.removeRepetition(16, rep);
785    }
786
787
788    /**
789     * Removes a repetition of
790     * RXA-16: "Substance Expiration Date" at a specific index
791     *
792     * @param rep The repetition index (0-indexed)
793     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
794     */
795    public TS removeRxa16_SubstanceExpirationDate(int rep) throws HL7Exception { 
796        return (TS) super.removeRepetition(16, rep);
797    }
798
799
800
801    /**
802     * Returns all repetitions of Substance Manufacturer Name (RXA-17).
803     */
804    public CE[] getSubstanceManufacturerName() {
805        CE[] retVal = this.getTypedField(17, new CE[0]);
806        return retVal;
807    }
808
809
810    /**
811     * Returns all repetitions of Substance Manufacturer Name (RXA-17).
812     */
813    public CE[] getRxa17_SubstanceManufacturerName() {
814        CE[] retVal = this.getTypedField(17, new CE[0]);
815        return retVal;
816    }
817
818
819    /**
820     * Returns a count of the current number of repetitions of Substance Manufacturer Name (RXA-17).
821     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
822     * it will return zero.
823     */
824    public int getSubstanceManufacturerNameReps() {
825        return this.getReps(17);
826    }
827
828
829    /**
830     * Returns a specific repetition of
831     * RXA-17: "Substance Manufacturer Name" - creates it if necessary
832     *
833     * @param rep The repetition index (0-indexed)
834     */
835    public CE getSubstanceManufacturerName(int rep) { 
836                CE retVal = this.getTypedField(17, rep);
837                return retVal;
838    }
839
840    /**
841     * Returns a specific repetition of
842     * RXA-17: "Substance Manufacturer Name" - creates it if necessary
843     *
844     * @param rep The repetition index (0-indexed)
845     */
846    public CE getRxa17_SubstanceManufacturerName(int rep) { 
847                CE retVal = this.getTypedField(17, rep);
848                return retVal;
849    }
850
851    /**
852     * Returns a count of the current number of repetitions of Substance Manufacturer Name (RXA-17).
853     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
854     * it will return zero.
855     */
856    public int getRxa17_SubstanceManufacturerNameReps() {
857        return this.getReps(17);
858    }
859
860
861    /**
862     * Inserts a repetition of
863     * RXA-17: "Substance Manufacturer Name" at a specific index
864     *
865     * @param rep The repetition index (0-indexed)
866     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
867     */
868    public CE insertSubstanceManufacturerName(int rep) throws HL7Exception { 
869        return (CE) super.insertRepetition(17, rep);
870    }
871
872
873    /**
874     * Inserts a repetition of
875     * RXA-17: "Substance Manufacturer Name" at a specific index
876     *
877     * @param rep The repetition index (0-indexed)
878     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
879     */
880    public CE insertRxa17_SubstanceManufacturerName(int rep) throws HL7Exception { 
881        return (CE) super.insertRepetition(17, rep);
882    }
883
884
885    /**
886     * Removes a repetition of
887     * RXA-17: "Substance Manufacturer Name" at a specific index
888     *
889     * @param rep The repetition index (0-indexed)
890     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
891     */
892    public CE removeSubstanceManufacturerName(int rep) throws HL7Exception { 
893        return (CE) super.removeRepetition(17, rep);
894    }
895
896
897    /**
898     * Removes a repetition of
899     * RXA-17: "Substance Manufacturer Name" at a specific index
900     *
901     * @param rep The repetition index (0-indexed)
902     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
903     */
904    public CE removeRxa17_SubstanceManufacturerName(int rep) throws HL7Exception { 
905        return (CE) super.removeRepetition(17, rep);
906    }
907
908
909
910    /**
911     * Returns all repetitions of Substance/Treatment Refusal Reason (RXA-18).
912     */
913    public CE[] getSubstanceTreatmentRefusalReason() {
914        CE[] retVal = this.getTypedField(18, new CE[0]);
915        return retVal;
916    }
917
918
919    /**
920     * Returns all repetitions of Substance/Treatment Refusal Reason (RXA-18).
921     */
922    public CE[] getRxa18_SubstanceTreatmentRefusalReason() {
923        CE[] retVal = this.getTypedField(18, new CE[0]);
924        return retVal;
925    }
926
927
928    /**
929     * Returns a count of the current number of repetitions of Substance/Treatment Refusal Reason (RXA-18).
930     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
931     * it will return zero.
932     */
933    public int getSubstanceTreatmentRefusalReasonReps() {
934        return this.getReps(18);
935    }
936
937
938    /**
939     * Returns a specific repetition of
940     * RXA-18: "Substance/Treatment Refusal Reason" - creates it if necessary
941     *
942     * @param rep The repetition index (0-indexed)
943     */
944    public CE getSubstanceTreatmentRefusalReason(int rep) { 
945                CE retVal = this.getTypedField(18, rep);
946                return retVal;
947    }
948
949    /**
950     * Returns a specific repetition of
951     * RXA-18: "Substance/Treatment Refusal Reason" - creates it if necessary
952     *
953     * @param rep The repetition index (0-indexed)
954     */
955    public CE getRxa18_SubstanceTreatmentRefusalReason(int rep) { 
956                CE retVal = this.getTypedField(18, rep);
957                return retVal;
958    }
959
960    /**
961     * Returns a count of the current number of repetitions of Substance/Treatment Refusal Reason (RXA-18).
962     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
963     * it will return zero.
964     */
965    public int getRxa18_SubstanceTreatmentRefusalReasonReps() {
966        return this.getReps(18);
967    }
968
969
970    /**
971     * Inserts a repetition of
972     * RXA-18: "Substance/Treatment Refusal Reason" at a specific index
973     *
974     * @param rep The repetition index (0-indexed)
975     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
976     */
977    public CE insertSubstanceTreatmentRefusalReason(int rep) throws HL7Exception { 
978        return (CE) super.insertRepetition(18, rep);
979    }
980
981
982    /**
983     * Inserts a repetition of
984     * RXA-18: "Substance/Treatment Refusal Reason" at a specific index
985     *
986     * @param rep The repetition index (0-indexed)
987     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
988     */
989    public CE insertRxa18_SubstanceTreatmentRefusalReason(int rep) throws HL7Exception { 
990        return (CE) super.insertRepetition(18, rep);
991    }
992
993
994    /**
995     * Removes a repetition of
996     * RXA-18: "Substance/Treatment Refusal Reason" at a specific index
997     *
998     * @param rep The repetition index (0-indexed)
999     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1000     */
1001    public CE removeSubstanceTreatmentRefusalReason(int rep) throws HL7Exception { 
1002        return (CE) super.removeRepetition(18, rep);
1003    }
1004
1005
1006    /**
1007     * Removes a repetition of
1008     * RXA-18: "Substance/Treatment Refusal Reason" at a specific index
1009     *
1010     * @param rep The repetition index (0-indexed)
1011     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1012     */
1013    public CE removeRxa18_SubstanceTreatmentRefusalReason(int rep) throws HL7Exception { 
1014        return (CE) super.removeRepetition(18, rep);
1015    }
1016
1017
1018
1019    /**
1020     * Returns all repetitions of Indication (RXA-19).
1021     */
1022    public CE[] getIndication() {
1023        CE[] retVal = this.getTypedField(19, new CE[0]);
1024        return retVal;
1025    }
1026
1027
1028    /**
1029     * Returns all repetitions of Indication (RXA-19).
1030     */
1031    public CE[] getRxa19_Indication() {
1032        CE[] retVal = this.getTypedField(19, new CE[0]);
1033        return retVal;
1034    }
1035
1036
1037    /**
1038     * Returns a count of the current number of repetitions of Indication (RXA-19).
1039     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1040     * it will return zero.
1041     */
1042    public int getIndicationReps() {
1043        return this.getReps(19);
1044    }
1045
1046
1047    /**
1048     * Returns a specific repetition of
1049     * RXA-19: "Indication" - creates it if necessary
1050     *
1051     * @param rep The repetition index (0-indexed)
1052     */
1053    public CE getIndication(int rep) { 
1054                CE retVal = this.getTypedField(19, rep);
1055                return retVal;
1056    }
1057
1058    /**
1059     * Returns a specific repetition of
1060     * RXA-19: "Indication" - creates it if necessary
1061     *
1062     * @param rep The repetition index (0-indexed)
1063     */
1064    public CE getRxa19_Indication(int rep) { 
1065                CE retVal = this.getTypedField(19, rep);
1066                return retVal;
1067    }
1068
1069    /**
1070     * Returns a count of the current number of repetitions of Indication (RXA-19).
1071     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
1072     * it will return zero.
1073     */
1074    public int getRxa19_IndicationReps() {
1075        return this.getReps(19);
1076    }
1077
1078
1079    /**
1080     * Inserts a repetition of
1081     * RXA-19: "Indication" at a specific index
1082     *
1083     * @param rep The repetition index (0-indexed)
1084     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1085     */
1086    public CE insertIndication(int rep) throws HL7Exception { 
1087        return (CE) super.insertRepetition(19, rep);
1088    }
1089
1090
1091    /**
1092     * Inserts a repetition of
1093     * RXA-19: "Indication" at a specific index
1094     *
1095     * @param rep The repetition index (0-indexed)
1096     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1097     */
1098    public CE insertRxa19_Indication(int rep) throws HL7Exception { 
1099        return (CE) super.insertRepetition(19, rep);
1100    }
1101
1102
1103    /**
1104     * Removes a repetition of
1105     * RXA-19: "Indication" at a specific index
1106     *
1107     * @param rep The repetition index (0-indexed)
1108     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1109     */
1110    public CE removeIndication(int rep) throws HL7Exception { 
1111        return (CE) super.removeRepetition(19, rep);
1112    }
1113
1114
1115    /**
1116     * Removes a repetition of
1117     * RXA-19: "Indication" at a specific index
1118     *
1119     * @param rep The repetition index (0-indexed)
1120     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
1121     */
1122    public CE removeRxa19_Indication(int rep) throws HL7Exception { 
1123        return (CE) super.removeRepetition(19, rep);
1124    }
1125
1126
1127
1128
1129    /**
1130     * Returns
1131     * RXA-20: "Completion Status" - creates it if necessary
1132     */
1133    public ID getCompletionStatus() { 
1134                ID retVal = this.getTypedField(20, 0);
1135                return retVal;
1136    }
1137    
1138    /**
1139     * Returns
1140     * RXA-20: "Completion Status" - creates it if necessary
1141     */
1142    public ID getRxa20_CompletionStatus() { 
1143                ID retVal = this.getTypedField(20, 0);
1144                return retVal;
1145    }
1146
1147
1148
1149    /**
1150     * Returns
1151     * RXA-21: "Action Code - RXA" - creates it if necessary
1152     */
1153    public ID getActionCodeRXA() { 
1154                ID retVal = this.getTypedField(21, 0);
1155                return retVal;
1156    }
1157    
1158    /**
1159     * Returns
1160     * RXA-21: "Action Code - RXA" - creates it if necessary
1161     */
1162    public ID getRxa21_ActionCodeRXA() { 
1163                ID retVal = this.getTypedField(21, 0);
1164                return retVal;
1165    }
1166
1167
1168
1169    /**
1170     * Returns
1171     * RXA-22: "System Entry Date/Time" - creates it if necessary
1172     */
1173    public TS getSystemEntryDateTime() { 
1174                TS retVal = this.getTypedField(22, 0);
1175                return retVal;
1176    }
1177    
1178    /**
1179     * Returns
1180     * RXA-22: "System Entry Date/Time" - creates it if necessary
1181     */
1182    public TS getRxa22_SystemEntryDateTime() { 
1183                TS retVal = this.getTypedField(22, 0);
1184                return retVal;
1185    }
1186
1187
1188
1189    /**
1190     * Returns
1191     * RXA-23: "Administered Drug Strength Volume" - creates it if necessary
1192     */
1193    public NM getAdministeredDrugStrengthVolume() { 
1194                NM retVal = this.getTypedField(23, 0);
1195                return retVal;
1196    }
1197    
1198    /**
1199     * Returns
1200     * RXA-23: "Administered Drug Strength Volume" - creates it if necessary
1201     */
1202    public NM getRxa23_AdministeredDrugStrengthVolume() { 
1203                NM retVal = this.getTypedField(23, 0);
1204                return retVal;
1205    }
1206
1207
1208
1209    /**
1210     * Returns
1211     * RXA-24: "Administered Drug Strength Volume Units" - creates it if necessary
1212     */
1213    public CWE getAdministeredDrugStrengthVolumeUnits() { 
1214                CWE retVal = this.getTypedField(24, 0);
1215                return retVal;
1216    }
1217    
1218    /**
1219     * Returns
1220     * RXA-24: "Administered Drug Strength Volume Units" - creates it if necessary
1221     */
1222    public CWE getRxa24_AdministeredDrugStrengthVolumeUnits() { 
1223                CWE retVal = this.getTypedField(24, 0);
1224                return retVal;
1225    }
1226
1227
1228
1229    /**
1230     * Returns
1231     * RXA-25: "Administered Barcode Identifier" - creates it if necessary
1232     */
1233    public CWE getAdministeredBarcodeIdentifier() { 
1234                CWE retVal = this.getTypedField(25, 0);
1235                return retVal;
1236    }
1237    
1238    /**
1239     * Returns
1240     * RXA-25: "Administered Barcode Identifier" - creates it if necessary
1241     */
1242    public CWE getRxa25_AdministeredBarcodeIdentifier() { 
1243                CWE retVal = this.getTypedField(25, 0);
1244                return retVal;
1245    }
1246
1247
1248
1249    /**
1250     * Returns
1251     * RXA-26: "Pharmacy Order Type" - creates it if necessary
1252     */
1253    public ID getPharmacyOrderType() { 
1254                ID retVal = this.getTypedField(26, 0);
1255                return retVal;
1256    }
1257    
1258    /**
1259     * Returns
1260     * RXA-26: "Pharmacy Order Type" - creates it if necessary
1261     */
1262    public ID getRxa26_PharmacyOrderType() { 
1263                ID retVal = this.getTypedField(26, 0);
1264                return retVal;
1265    }
1266
1267
1268
1269
1270
1271    /** {@inheritDoc} */   
1272    protected Type createNewTypeWithoutReflection(int field) {
1273       switch (field) {
1274          case 0: return new NM(getMessage());
1275          case 1: return new NM(getMessage());
1276          case 2: return new TS(getMessage());
1277          case 3: return new TS(getMessage());
1278          case 4: return new CE(getMessage());
1279          case 5: return new NM(getMessage());
1280          case 6: return new CE(getMessage());
1281          case 7: return new CE(getMessage());
1282          case 8: return new CE(getMessage());
1283          case 9: return new XCN(getMessage());
1284          case 10: return new LA2(getMessage());
1285          case 11: return new ST(getMessage());
1286          case 12: return new NM(getMessage());
1287          case 13: return new CE(getMessage());
1288          case 14: return new ST(getMessage());
1289          case 15: return new TS(getMessage());
1290          case 16: return new CE(getMessage());
1291          case 17: return new CE(getMessage());
1292          case 18: return new CE(getMessage());
1293          case 19: return new ID(getMessage(), new Integer( 322 ));
1294          case 20: return new ID(getMessage(), new Integer( 323 ));
1295          case 21: return new TS(getMessage());
1296          case 22: return new NM(getMessage());
1297          case 23: return new CWE(getMessage());
1298          case 24: return new CWE(getMessage());
1299          case 25: return new ID(getMessage(), new Integer( 480 ));
1300          default: return null;
1301       }
1302   }
1303
1304
1305}
1306