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 PR1 message segment (Procedures). 
050 * This segment has the following fields:</p>
051 * <ul>
052     * <li>PR1-1: Set ID - PR1 (SI) <b> </b>
053     * <li>PR1-2: Procedure Coding Method (IS) <b>optional </b>
054     * <li>PR1-3: Procedure Code (CE) <b> </b>
055     * <li>PR1-4: Procedure Description (ST) <b>optional </b>
056     * <li>PR1-5: Procedure Date/Time (TS) <b> </b>
057     * <li>PR1-6: Procedure Functional Type (IS) <b>optional </b>
058     * <li>PR1-7: Procedure Minutes (NM) <b>optional </b>
059     * <li>PR1-8: Anesthesiologist (XCN) <b>optional repeating</b>
060     * <li>PR1-9: Anesthesia Code (IS) <b>optional </b>
061     * <li>PR1-10: Anesthesia Minutes (NM) <b>optional </b>
062     * <li>PR1-11: Surgeon (XCN) <b>optional repeating</b>
063     * <li>PR1-12: Procedure Practitioner (XCN) <b>optional repeating</b>
064     * <li>PR1-13: Consent Code (CE) <b>optional </b>
065     * <li>PR1-14: Procedure Priority (ID) <b>optional </b>
066     * <li>PR1-15: Associated Diagnosis Code (CE) <b>optional </b>
067     * <li>PR1-16: Procedure Code Modifier (CE) <b>optional repeating</b>
068     * <li>PR1-17: Procedure DRG Type (IS) <b>optional </b>
069     * <li>PR1-18: Tissue Type Code (CE) <b>optional repeating</b>
070     * <li>PR1-19: Procedure Identifier (EI) <b>optional </b>
071     * <li>PR1-20: Procedure Action Code (ID) <b>optional </b>
072 * </ul>
073 */
074@SuppressWarnings("unused")
075public class PR1 extends AbstractSegment {
076
077    /** 
078     * Creates a new PR1 segment
079     */
080    public PR1(Group parent, ModelClassFactory factory) {
081       super(parent, factory);
082       init(factory);
083    }
084
085    private void init(ModelClassFactory factory) {
086       try {
087                                  this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - PR1");
088                                              this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(89) }, "Procedure Coding Method");
089                                  this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Procedure Code");
090                                  this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Procedure Description");
091                                  this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Procedure Date/Time");
092                                              this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(230) }, "Procedure Functional Type");
093                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Procedure Minutes");
094                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Anesthesiologist");
095                                              this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(19) }, "Anesthesia Code");
096                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Anesthesia Minutes");
097                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Surgeon");
098                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Procedure Practitioner");
099                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Consent Code");
100                                              this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(418) }, "Procedure Priority");
101                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Associated Diagnosis Code");
102                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Procedure Code Modifier");
103                                              this.add(IS.class, false, 1, 20, new Object[]{ getMessage(), new Integer(416) }, "Procedure DRG Type");
104                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Tissue Type Code");
105                                  this.add(EI.class, false, 1, 427, new Object[]{ getMessage() }, "Procedure Identifier");
106                                              this.add(ID.class, false, 1, 1, new Object[]{ getMessage(), new Integer(206) }, "Procedure Action Code");
107       } catch(HL7Exception e) {
108          log.error("Unexpected error creating PR1 - this is probably a bug in the source code generator.", e);
109       }
110    }
111
112
113
114    /**
115     * Returns
116     * PR1-1: "Set ID - PR1" - creates it if necessary
117     */
118    public SI getSetIDPR1() { 
119                SI retVal = this.getTypedField(1, 0);
120                return retVal;
121    }
122    
123    /**
124     * Returns
125     * PR1-1: "Set ID - PR1" - creates it if necessary
126     */
127    public SI getPr11_SetIDPR1() { 
128                SI retVal = this.getTypedField(1, 0);
129                return retVal;
130    }
131
132
133
134    /**
135     * Returns
136     * PR1-2: "Procedure Coding Method" - creates it if necessary
137     */
138    public IS getProcedureCodingMethod() { 
139                IS retVal = this.getTypedField(2, 0);
140                return retVal;
141    }
142    
143    /**
144     * Returns
145     * PR1-2: "Procedure Coding Method" - creates it if necessary
146     */
147    public IS getPr12_ProcedureCodingMethod() { 
148                IS retVal = this.getTypedField(2, 0);
149                return retVal;
150    }
151
152
153
154    /**
155     * Returns
156     * PR1-3: "Procedure Code" - creates it if necessary
157     */
158    public CE getProcedureCode() { 
159                CE retVal = this.getTypedField(3, 0);
160                return retVal;
161    }
162    
163    /**
164     * Returns
165     * PR1-3: "Procedure Code" - creates it if necessary
166     */
167    public CE getPr13_ProcedureCode() { 
168                CE retVal = this.getTypedField(3, 0);
169                return retVal;
170    }
171
172
173
174    /**
175     * Returns
176     * PR1-4: "Procedure Description" - creates it if necessary
177     */
178    public ST getProcedureDescription() { 
179                ST retVal = this.getTypedField(4, 0);
180                return retVal;
181    }
182    
183    /**
184     * Returns
185     * PR1-4: "Procedure Description" - creates it if necessary
186     */
187    public ST getPr14_ProcedureDescription() { 
188                ST retVal = this.getTypedField(4, 0);
189                return retVal;
190    }
191
192
193
194    /**
195     * Returns
196     * PR1-5: "Procedure Date/Time" - creates it if necessary
197     */
198    public TS getProcedureDateTime() { 
199                TS retVal = this.getTypedField(5, 0);
200                return retVal;
201    }
202    
203    /**
204     * Returns
205     * PR1-5: "Procedure Date/Time" - creates it if necessary
206     */
207    public TS getPr15_ProcedureDateTime() { 
208                TS retVal = this.getTypedField(5, 0);
209                return retVal;
210    }
211
212
213
214    /**
215     * Returns
216     * PR1-6: "Procedure Functional Type" - creates it if necessary
217     */
218    public IS getProcedureFunctionalType() { 
219                IS retVal = this.getTypedField(6, 0);
220                return retVal;
221    }
222    
223    /**
224     * Returns
225     * PR1-6: "Procedure Functional Type" - creates it if necessary
226     */
227    public IS getPr16_ProcedureFunctionalType() { 
228                IS retVal = this.getTypedField(6, 0);
229                return retVal;
230    }
231
232
233
234    /**
235     * Returns
236     * PR1-7: "Procedure Minutes" - creates it if necessary
237     */
238    public NM getProcedureMinutes() { 
239                NM retVal = this.getTypedField(7, 0);
240                return retVal;
241    }
242    
243    /**
244     * Returns
245     * PR1-7: "Procedure Minutes" - creates it if necessary
246     */
247    public NM getPr17_ProcedureMinutes() { 
248                NM retVal = this.getTypedField(7, 0);
249                return retVal;
250    }
251
252
253    /**
254     * Returns all repetitions of Anesthesiologist (PR1-8).
255     */
256    public XCN[] getAnesthesiologist() {
257        XCN[] retVal = this.getTypedField(8, new XCN[0]);
258        return retVal;
259    }
260
261
262    /**
263     * Returns all repetitions of Anesthesiologist (PR1-8).
264     */
265    public XCN[] getPr18_Anesthesiologist() {
266        XCN[] retVal = this.getTypedField(8, new XCN[0]);
267        return retVal;
268    }
269
270
271    /**
272     * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8).
273     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
274     * it will return zero.
275     */
276    public int getAnesthesiologistReps() {
277        return this.getReps(8);
278    }
279
280
281    /**
282     * Returns a specific repetition of
283     * PR1-8: "Anesthesiologist" - creates it if necessary
284     *
285     * @param rep The repetition index (0-indexed)
286     */
287    public XCN getAnesthesiologist(int rep) { 
288                XCN retVal = this.getTypedField(8, rep);
289                return retVal;
290    }
291
292    /**
293     * Returns a specific repetition of
294     * PR1-8: "Anesthesiologist" - creates it if necessary
295     *
296     * @param rep The repetition index (0-indexed)
297     */
298    public XCN getPr18_Anesthesiologist(int rep) { 
299                XCN retVal = this.getTypedField(8, rep);
300                return retVal;
301    }
302
303    /**
304     * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8).
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 getPr18_AnesthesiologistReps() {
309        return this.getReps(8);
310    }
311
312
313    /**
314     * Inserts a repetition of
315     * PR1-8: "Anesthesiologist" at a specific index
316     *
317     * @param rep The repetition index (0-indexed)
318     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
319     */
320    public XCN insertAnesthesiologist(int rep) throws HL7Exception { 
321        return (XCN) super.insertRepetition(8, rep);
322    }
323
324
325    /**
326     * Inserts a repetition of
327     * PR1-8: "Anesthesiologist" at a specific index
328     *
329     * @param rep The repetition index (0-indexed)
330     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
331     */
332    public XCN insertPr18_Anesthesiologist(int rep) throws HL7Exception { 
333        return (XCN) super.insertRepetition(8, rep);
334    }
335
336
337    /**
338     * Removes a repetition of
339     * PR1-8: "Anesthesiologist" 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 XCN removeAnesthesiologist(int rep) throws HL7Exception { 
345        return (XCN) super.removeRepetition(8, rep);
346    }
347
348
349    /**
350     * Removes a repetition of
351     * PR1-8: "Anesthesiologist" 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 XCN removePr18_Anesthesiologist(int rep) throws HL7Exception { 
357        return (XCN) super.removeRepetition(8, rep);
358    }
359
360
361
362
363    /**
364     * Returns
365     * PR1-9: "Anesthesia Code" - creates it if necessary
366     */
367    public IS getAnesthesiaCode() { 
368                IS retVal = this.getTypedField(9, 0);
369                return retVal;
370    }
371    
372    /**
373     * Returns
374     * PR1-9: "Anesthesia Code" - creates it if necessary
375     */
376    public IS getPr19_AnesthesiaCode() { 
377                IS retVal = this.getTypedField(9, 0);
378                return retVal;
379    }
380
381
382
383    /**
384     * Returns
385     * PR1-10: "Anesthesia Minutes" - creates it if necessary
386     */
387    public NM getAnesthesiaMinutes() { 
388                NM retVal = this.getTypedField(10, 0);
389                return retVal;
390    }
391    
392    /**
393     * Returns
394     * PR1-10: "Anesthesia Minutes" - creates it if necessary
395     */
396    public NM getPr110_AnesthesiaMinutes() { 
397                NM retVal = this.getTypedField(10, 0);
398                return retVal;
399    }
400
401
402    /**
403     * Returns all repetitions of Surgeon (PR1-11).
404     */
405    public XCN[] getSurgeon() {
406        XCN[] retVal = this.getTypedField(11, new XCN[0]);
407        return retVal;
408    }
409
410
411    /**
412     * Returns all repetitions of Surgeon (PR1-11).
413     */
414    public XCN[] getPr111_Surgeon() {
415        XCN[] retVal = this.getTypedField(11, new XCN[0]);
416        return retVal;
417    }
418
419
420    /**
421     * Returns a count of the current number of repetitions of Surgeon (PR1-11).
422     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
423     * it will return zero.
424     */
425    public int getSurgeonReps() {
426        return this.getReps(11);
427    }
428
429
430    /**
431     * Returns a specific repetition of
432     * PR1-11: "Surgeon" - creates it if necessary
433     *
434     * @param rep The repetition index (0-indexed)
435     */
436    public XCN getSurgeon(int rep) { 
437                XCN retVal = this.getTypedField(11, rep);
438                return retVal;
439    }
440
441    /**
442     * Returns a specific repetition of
443     * PR1-11: "Surgeon" - creates it if necessary
444     *
445     * @param rep The repetition index (0-indexed)
446     */
447    public XCN getPr111_Surgeon(int rep) { 
448                XCN retVal = this.getTypedField(11, rep);
449                return retVal;
450    }
451
452    /**
453     * Returns a count of the current number of repetitions of Surgeon (PR1-11).
454     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
455     * it will return zero.
456     */
457    public int getPr111_SurgeonReps() {
458        return this.getReps(11);
459    }
460
461
462    /**
463     * Inserts a repetition of
464     * PR1-11: "Surgeon" at a specific index
465     *
466     * @param rep The repetition index (0-indexed)
467     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
468     */
469    public XCN insertSurgeon(int rep) throws HL7Exception { 
470        return (XCN) super.insertRepetition(11, rep);
471    }
472
473
474    /**
475     * Inserts a repetition of
476     * PR1-11: "Surgeon" at a specific index
477     *
478     * @param rep The repetition index (0-indexed)
479     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
480     */
481    public XCN insertPr111_Surgeon(int rep) throws HL7Exception { 
482        return (XCN) super.insertRepetition(11, rep);
483    }
484
485
486    /**
487     * Removes a repetition of
488     * PR1-11: "Surgeon" at a specific index
489     *
490     * @param rep The repetition index (0-indexed)
491     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
492     */
493    public XCN removeSurgeon(int rep) throws HL7Exception { 
494        return (XCN) super.removeRepetition(11, rep);
495    }
496
497
498    /**
499     * Removes a repetition of
500     * PR1-11: "Surgeon" at a specific index
501     *
502     * @param rep The repetition index (0-indexed)
503     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
504     */
505    public XCN removePr111_Surgeon(int rep) throws HL7Exception { 
506        return (XCN) super.removeRepetition(11, rep);
507    }
508
509
510
511    /**
512     * Returns all repetitions of Procedure Practitioner (PR1-12).
513     */
514    public XCN[] getProcedurePractitioner() {
515        XCN[] retVal = this.getTypedField(12, new XCN[0]);
516        return retVal;
517    }
518
519
520    /**
521     * Returns all repetitions of Procedure Practitioner (PR1-12).
522     */
523    public XCN[] getPr112_ProcedurePractitioner() {
524        XCN[] retVal = this.getTypedField(12, new XCN[0]);
525        return retVal;
526    }
527
528
529    /**
530     * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12).
531     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
532     * it will return zero.
533     */
534    public int getProcedurePractitionerReps() {
535        return this.getReps(12);
536    }
537
538
539    /**
540     * Returns a specific repetition of
541     * PR1-12: "Procedure Practitioner" - creates it if necessary
542     *
543     * @param rep The repetition index (0-indexed)
544     */
545    public XCN getProcedurePractitioner(int rep) { 
546                XCN retVal = this.getTypedField(12, rep);
547                return retVal;
548    }
549
550    /**
551     * Returns a specific repetition of
552     * PR1-12: "Procedure Practitioner" - creates it if necessary
553     *
554     * @param rep The repetition index (0-indexed)
555     */
556    public XCN getPr112_ProcedurePractitioner(int rep) { 
557                XCN retVal = this.getTypedField(12, rep);
558                return retVal;
559    }
560
561    /**
562     * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12).
563     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
564     * it will return zero.
565     */
566    public int getPr112_ProcedurePractitionerReps() {
567        return this.getReps(12);
568    }
569
570
571    /**
572     * Inserts a repetition of
573     * PR1-12: "Procedure Practitioner" at a specific index
574     *
575     * @param rep The repetition index (0-indexed)
576     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
577     */
578    public XCN insertProcedurePractitioner(int rep) throws HL7Exception { 
579        return (XCN) super.insertRepetition(12, rep);
580    }
581
582
583    /**
584     * Inserts a repetition of
585     * PR1-12: "Procedure Practitioner" at a specific index
586     *
587     * @param rep The repetition index (0-indexed)
588     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
589     */
590    public XCN insertPr112_ProcedurePractitioner(int rep) throws HL7Exception { 
591        return (XCN) super.insertRepetition(12, rep);
592    }
593
594
595    /**
596     * Removes a repetition of
597     * PR1-12: "Procedure Practitioner" at a specific index
598     *
599     * @param rep The repetition index (0-indexed)
600     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
601     */
602    public XCN removeProcedurePractitioner(int rep) throws HL7Exception { 
603        return (XCN) super.removeRepetition(12, rep);
604    }
605
606
607    /**
608     * Removes a repetition of
609     * PR1-12: "Procedure Practitioner" at a specific index
610     *
611     * @param rep The repetition index (0-indexed)
612     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
613     */
614    public XCN removePr112_ProcedurePractitioner(int rep) throws HL7Exception { 
615        return (XCN) super.removeRepetition(12, rep);
616    }
617
618
619
620
621    /**
622     * Returns
623     * PR1-13: "Consent Code" - creates it if necessary
624     */
625    public CE getConsentCode() { 
626                CE retVal = this.getTypedField(13, 0);
627                return retVal;
628    }
629    
630    /**
631     * Returns
632     * PR1-13: "Consent Code" - creates it if necessary
633     */
634    public CE getPr113_ConsentCode() { 
635                CE retVal = this.getTypedField(13, 0);
636                return retVal;
637    }
638
639
640
641    /**
642     * Returns
643     * PR1-14: "Procedure Priority" - creates it if necessary
644     */
645    public ID getProcedurePriority() { 
646                ID retVal = this.getTypedField(14, 0);
647                return retVal;
648    }
649    
650    /**
651     * Returns
652     * PR1-14: "Procedure Priority" - creates it if necessary
653     */
654    public ID getPr114_ProcedurePriority() { 
655                ID retVal = this.getTypedField(14, 0);
656                return retVal;
657    }
658
659
660
661    /**
662     * Returns
663     * PR1-15: "Associated Diagnosis Code" - creates it if necessary
664     */
665    public CE getAssociatedDiagnosisCode() { 
666                CE retVal = this.getTypedField(15, 0);
667                return retVal;
668    }
669    
670    /**
671     * Returns
672     * PR1-15: "Associated Diagnosis Code" - creates it if necessary
673     */
674    public CE getPr115_AssociatedDiagnosisCode() { 
675                CE retVal = this.getTypedField(15, 0);
676                return retVal;
677    }
678
679
680    /**
681     * Returns all repetitions of Procedure Code Modifier (PR1-16).
682     */
683    public CE[] getProcedureCodeModifier() {
684        CE[] retVal = this.getTypedField(16, new CE[0]);
685        return retVal;
686    }
687
688
689    /**
690     * Returns all repetitions of Procedure Code Modifier (PR1-16).
691     */
692    public CE[] getPr116_ProcedureCodeModifier() {
693        CE[] retVal = this.getTypedField(16, new CE[0]);
694        return retVal;
695    }
696
697
698    /**
699     * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16).
700     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
701     * it will return zero.
702     */
703    public int getProcedureCodeModifierReps() {
704        return this.getReps(16);
705    }
706
707
708    /**
709     * Returns a specific repetition of
710     * PR1-16: "Procedure Code Modifier" - creates it if necessary
711     *
712     * @param rep The repetition index (0-indexed)
713     */
714    public CE getProcedureCodeModifier(int rep) { 
715                CE retVal = this.getTypedField(16, rep);
716                return retVal;
717    }
718
719    /**
720     * Returns a specific repetition of
721     * PR1-16: "Procedure Code Modifier" - creates it if necessary
722     *
723     * @param rep The repetition index (0-indexed)
724     */
725    public CE getPr116_ProcedureCodeModifier(int rep) { 
726                CE retVal = this.getTypedField(16, rep);
727                return retVal;
728    }
729
730    /**
731     * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16).
732     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
733     * it will return zero.
734     */
735    public int getPr116_ProcedureCodeModifierReps() {
736        return this.getReps(16);
737    }
738
739
740    /**
741     * Inserts a repetition of
742     * PR1-16: "Procedure Code Modifier" at a specific index
743     *
744     * @param rep The repetition index (0-indexed)
745     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
746     */
747    public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 
748        return (CE) super.insertRepetition(16, rep);
749    }
750
751
752    /**
753     * Inserts a repetition of
754     * PR1-16: "Procedure Code Modifier" 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 CE insertPr116_ProcedureCodeModifier(int rep) throws HL7Exception { 
760        return (CE) super.insertRepetition(16, rep);
761    }
762
763
764    /**
765     * Removes a repetition of
766     * PR1-16: "Procedure Code Modifier" 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 removeProcedureCodeModifier(int rep) throws HL7Exception { 
772        return (CE) super.removeRepetition(16, rep);
773    }
774
775
776    /**
777     * Removes a repetition of
778     * PR1-16: "Procedure Code Modifier" 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 removePr116_ProcedureCodeModifier(int rep) throws HL7Exception { 
784        return (CE) super.removeRepetition(16, rep);
785    }
786
787
788
789
790    /**
791     * Returns
792     * PR1-17: "Procedure DRG Type" - creates it if necessary
793     */
794    public IS getProcedureDRGType() { 
795                IS retVal = this.getTypedField(17, 0);
796                return retVal;
797    }
798    
799    /**
800     * Returns
801     * PR1-17: "Procedure DRG Type" - creates it if necessary
802     */
803    public IS getPr117_ProcedureDRGType() { 
804                IS retVal = this.getTypedField(17, 0);
805                return retVal;
806    }
807
808
809    /**
810     * Returns all repetitions of Tissue Type Code (PR1-18).
811     */
812    public CE[] getTissueTypeCode() {
813        CE[] retVal = this.getTypedField(18, new CE[0]);
814        return retVal;
815    }
816
817
818    /**
819     * Returns all repetitions of Tissue Type Code (PR1-18).
820     */
821    public CE[] getPr118_TissueTypeCode() {
822        CE[] retVal = this.getTypedField(18, new CE[0]);
823        return retVal;
824    }
825
826
827    /**
828     * Returns a count of the current number of repetitions of Tissue Type Code (PR1-18).
829     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
830     * it will return zero.
831     */
832    public int getTissueTypeCodeReps() {
833        return this.getReps(18);
834    }
835
836
837    /**
838     * Returns a specific repetition of
839     * PR1-18: "Tissue Type Code" - creates it if necessary
840     *
841     * @param rep The repetition index (0-indexed)
842     */
843    public CE getTissueTypeCode(int rep) { 
844                CE retVal = this.getTypedField(18, rep);
845                return retVal;
846    }
847
848    /**
849     * Returns a specific repetition of
850     * PR1-18: "Tissue Type Code" - creates it if necessary
851     *
852     * @param rep The repetition index (0-indexed)
853     */
854    public CE getPr118_TissueTypeCode(int rep) { 
855                CE retVal = this.getTypedField(18, rep);
856                return retVal;
857    }
858
859    /**
860     * Returns a count of the current number of repetitions of Tissue Type Code (PR1-18).
861     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
862     * it will return zero.
863     */
864    public int getPr118_TissueTypeCodeReps() {
865        return this.getReps(18);
866    }
867
868
869    /**
870     * Inserts a repetition of
871     * PR1-18: "Tissue Type Code" at a specific index
872     *
873     * @param rep The repetition index (0-indexed)
874     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
875     */
876    public CE insertTissueTypeCode(int rep) throws HL7Exception { 
877        return (CE) super.insertRepetition(18, rep);
878    }
879
880
881    /**
882     * Inserts a repetition of
883     * PR1-18: "Tissue Type Code" at a specific index
884     *
885     * @param rep The repetition index (0-indexed)
886     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
887     */
888    public CE insertPr118_TissueTypeCode(int rep) throws HL7Exception { 
889        return (CE) super.insertRepetition(18, rep);
890    }
891
892
893    /**
894     * Removes a repetition of
895     * PR1-18: "Tissue Type Code" at a specific index
896     *
897     * @param rep The repetition index (0-indexed)
898     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
899     */
900    public CE removeTissueTypeCode(int rep) throws HL7Exception { 
901        return (CE) super.removeRepetition(18, rep);
902    }
903
904
905    /**
906     * Removes a repetition of
907     * PR1-18: "Tissue Type Code" at a specific index
908     *
909     * @param rep The repetition index (0-indexed)
910     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
911     */
912    public CE removePr118_TissueTypeCode(int rep) throws HL7Exception { 
913        return (CE) super.removeRepetition(18, rep);
914    }
915
916
917
918
919    /**
920     * Returns
921     * PR1-19: "Procedure Identifier" - creates it if necessary
922     */
923    public EI getProcedureIdentifier() { 
924                EI retVal = this.getTypedField(19, 0);
925                return retVal;
926    }
927    
928    /**
929     * Returns
930     * PR1-19: "Procedure Identifier" - creates it if necessary
931     */
932    public EI getPr119_ProcedureIdentifier() { 
933                EI retVal = this.getTypedField(19, 0);
934                return retVal;
935    }
936
937
938
939    /**
940     * Returns
941     * PR1-20: "Procedure Action Code" - creates it if necessary
942     */
943    public ID getProcedureActionCode() { 
944                ID retVal = this.getTypedField(20, 0);
945                return retVal;
946    }
947    
948    /**
949     * Returns
950     * PR1-20: "Procedure Action Code" - creates it if necessary
951     */
952    public ID getPr120_ProcedureActionCode() { 
953                ID retVal = this.getTypedField(20, 0);
954                return retVal;
955    }
956
957
958
959
960
961    /** {@inheritDoc} */   
962    protected Type createNewTypeWithoutReflection(int field) {
963       switch (field) {
964          case 0: return new SI(getMessage());
965          case 1: return new IS(getMessage(), new Integer( 89 ));
966          case 2: return new CE(getMessage());
967          case 3: return new ST(getMessage());
968          case 4: return new TS(getMessage());
969          case 5: return new IS(getMessage(), new Integer( 230 ));
970          case 6: return new NM(getMessage());
971          case 7: return new XCN(getMessage());
972          case 8: return new IS(getMessage(), new Integer( 19 ));
973          case 9: return new NM(getMessage());
974          case 10: return new XCN(getMessage());
975          case 11: return new XCN(getMessage());
976          case 12: return new CE(getMessage());
977          case 13: return new ID(getMessage(), new Integer( 418 ));
978          case 14: return new CE(getMessage());
979          case 15: return new CE(getMessage());
980          case 16: return new IS(getMessage(), new Integer( 416 ));
981          case 17: return new CE(getMessage());
982          case 18: return new EI(getMessage());
983          case 19: return new ID(getMessage(), new Integer( 206 ));
984          default: return null;
985       }
986   }
987
988
989}
990