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