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