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.v231.segment;
035
036// import ca.uhn.hl7v2.model.v231.group.*;
037import ca.uhn.hl7v2.model.v231.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 PR1 message segment (PR1 - procedures segment). 
049 * This segment has the following fields:</p>
050 * <ul>
051     * <li>PR1-1: Set ID - PR1 (SI) <b> </b>
052     * <li>PR1-2: Procedure Coding Method (IS) <b>optional </b>
053     * <li>PR1-3: Procedure Code (CE) <b> </b>
054     * <li>PR1-4: Procedure Description (ST) <b>optional </b>
055     * <li>PR1-5: Procedure Date/Time (TS) <b> </b>
056     * <li>PR1-6: Procedure Functional Type (IS) <b> </b>
057     * <li>PR1-7: Procedure Minutes (NM) <b>optional </b>
058     * <li>PR1-8: Anesthesiologist (XCN) <b>optional repeating</b>
059     * <li>PR1-9: Anesthesia Code (IS) <b>optional </b>
060     * <li>PR1-10: Anesthesia Minutes (NM) <b>optional </b>
061     * <li>PR1-11: Surgeon (XCN) <b>optional repeating</b>
062     * <li>PR1-12: Procedure Practitioner (XCN) <b>optional repeating</b>
063     * <li>PR1-13: Consent Code (CE) <b>optional </b>
064     * <li>PR1-14: Procedure Priority (NM) <b>optional </b>
065     * <li>PR1-15: Associated Diagnosis Code (CE) <b>optional </b>
066     * <li>PR1-16: Procedure Code Modifier (CE) <b>optional repeating</b>
067 * </ul>
068 */
069@SuppressWarnings("unused")
070public class PR1 extends AbstractSegment {
071
072    /** 
073     * Creates a new PR1 segment
074     */
075    public PR1(Group parent, ModelClassFactory factory) {
076       super(parent, factory);
077       init(factory);
078    }
079
080    private void init(ModelClassFactory factory) {
081       try {
082                                  this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - PR1");
083                                              this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(89) }, "Procedure Coding Method");
084                                  this.add(CE.class, true, 1, 80, new Object[]{ getMessage() }, "Procedure Code");
085                                  this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Procedure Description");
086                                  this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Procedure Date/Time");
087                                              this.add(IS.class, true, 1, 2, new Object[]{ getMessage(), new Integer(230) }, "Procedure Functional Type");
088                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Procedure Minutes");
089                                  this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Anesthesiologist");
090                                              this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(19) }, "Anesthesia Code");
091                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Anesthesia Minutes");
092                                  this.add(XCN.class, false, 0, 120, new Object[]{ getMessage() }, "Surgeon");
093                                  this.add(XCN.class, false, 0, 230, new Object[]{ getMessage() }, "Procedure Practitioner");
094                                  this.add(CE.class, false, 1, 60, new Object[]{ getMessage() }, "Consent Code");
095                                  this.add(NM.class, false, 1, 2, new Object[]{ getMessage() }, "Procedure Priority");
096                                  this.add(CE.class, false, 1, 80, new Object[]{ getMessage() }, "Associated Diagnosis Code");
097                                  this.add(CE.class, false, 0, 80, new Object[]{ getMessage() }, "Procedure Code Modifier");
098       } catch(HL7Exception e) {
099          log.error("Unexpected error creating PR1 - this is probably a bug in the source code generator.", e);
100       }
101    }
102
103
104
105    /**
106     * Returns
107     * PR1-1: "Set ID - PR1" - creates it if necessary
108     */
109    public SI getSetIDPR1() { 
110                SI retVal = this.getTypedField(1, 0);
111                return retVal;
112    }
113    
114    /**
115     * Returns
116     * PR1-1: "Set ID - PR1" - creates it if necessary
117     */
118    public SI getPr11_SetIDPR1() { 
119                SI retVal = this.getTypedField(1, 0);
120                return retVal;
121    }
122
123
124
125    /**
126     * Returns
127     * PR1-2: "Procedure Coding Method" - creates it if necessary
128     */
129    public IS getProcedureCodingMethod() { 
130                IS retVal = this.getTypedField(2, 0);
131                return retVal;
132    }
133    
134    /**
135     * Returns
136     * PR1-2: "Procedure Coding Method" - creates it if necessary
137     */
138    public IS getPr12_ProcedureCodingMethod() { 
139                IS retVal = this.getTypedField(2, 0);
140                return retVal;
141    }
142
143
144
145    /**
146     * Returns
147     * PR1-3: "Procedure Code" - creates it if necessary
148     */
149    public CE getProcedureCode() { 
150                CE retVal = this.getTypedField(3, 0);
151                return retVal;
152    }
153    
154    /**
155     * Returns
156     * PR1-3: "Procedure Code" - creates it if necessary
157     */
158    public CE getPr13_ProcedureCode() { 
159                CE retVal = this.getTypedField(3, 0);
160                return retVal;
161    }
162
163
164
165    /**
166     * Returns
167     * PR1-4: "Procedure Description" - creates it if necessary
168     */
169    public ST getProcedureDescription() { 
170                ST retVal = this.getTypedField(4, 0);
171                return retVal;
172    }
173    
174    /**
175     * Returns
176     * PR1-4: "Procedure Description" - creates it if necessary
177     */
178    public ST getPr14_ProcedureDescription() { 
179                ST retVal = this.getTypedField(4, 0);
180                return retVal;
181    }
182
183
184
185    /**
186     * Returns
187     * PR1-5: "Procedure Date/Time" - creates it if necessary
188     */
189    public TS getProcedureDateTime() { 
190                TS retVal = this.getTypedField(5, 0);
191                return retVal;
192    }
193    
194    /**
195     * Returns
196     * PR1-5: "Procedure Date/Time" - creates it if necessary
197     */
198    public TS getPr15_ProcedureDateTime() { 
199                TS retVal = this.getTypedField(5, 0);
200                return retVal;
201    }
202
203
204
205    /**
206     * Returns
207     * PR1-6: "Procedure Functional Type" - creates it if necessary
208     */
209    public IS getProcedureFunctionalType() { 
210                IS retVal = this.getTypedField(6, 0);
211                return retVal;
212    }
213    
214    /**
215     * Returns
216     * PR1-6: "Procedure Functional Type" - creates it if necessary
217     */
218    public IS getPr16_ProcedureFunctionalType() { 
219                IS retVal = this.getTypedField(6, 0);
220                return retVal;
221    }
222
223
224
225    /**
226     * Returns
227     * PR1-7: "Procedure Minutes" - creates it if necessary
228     */
229    public NM getProcedureMinutes() { 
230                NM retVal = this.getTypedField(7, 0);
231                return retVal;
232    }
233    
234    /**
235     * Returns
236     * PR1-7: "Procedure Minutes" - creates it if necessary
237     */
238    public NM getPr17_ProcedureMinutes() { 
239                NM retVal = this.getTypedField(7, 0);
240                return retVal;
241    }
242
243
244    /**
245     * Returns all repetitions of Anesthesiologist (PR1-8).
246     */
247    public XCN[] getAnesthesiologist() {
248        XCN[] retVal = this.getTypedField(8, new XCN[0]);
249        return retVal;
250    }
251
252
253    /**
254     * Returns all repetitions of Anesthesiologist (PR1-8).
255     */
256    public XCN[] getPr18_Anesthesiologist() {
257        XCN[] retVal = this.getTypedField(8, new XCN[0]);
258        return retVal;
259    }
260
261
262    /**
263     * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8).
264     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
265     * it will return zero.
266     */
267    public int getAnesthesiologistReps() {
268        return this.getReps(8);
269    }
270
271
272    /**
273     * Returns a specific repetition of
274     * PR1-8: "Anesthesiologist" - creates it if necessary
275     *
276     * @param rep The repetition index (0-indexed)
277     */
278    public XCN getAnesthesiologist(int rep) { 
279                XCN retVal = this.getTypedField(8, rep);
280                return retVal;
281    }
282
283    /**
284     * Returns a specific repetition of
285     * PR1-8: "Anesthesiologist" - creates it if necessary
286     *
287     * @param rep The repetition index (0-indexed)
288     */
289    public XCN getPr18_Anesthesiologist(int rep) { 
290                XCN retVal = this.getTypedField(8, rep);
291                return retVal;
292    }
293
294    /**
295     * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8).
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 getPr18_AnesthesiologistReps() {
300        return this.getReps(8);
301    }
302
303
304    /**
305     * Inserts a repetition of
306     * PR1-8: "Anesthesiologist" at a specific index
307     *
308     * @param rep The repetition index (0-indexed)
309     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
310     */
311    public XCN insertAnesthesiologist(int rep) throws HL7Exception { 
312        return (XCN) super.insertRepetition(8, rep);
313    }
314
315
316    /**
317     * Inserts a repetition of
318     * PR1-8: "Anesthesiologist" at a specific index
319     *
320     * @param rep The repetition index (0-indexed)
321     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
322     */
323    public XCN insertPr18_Anesthesiologist(int rep) throws HL7Exception { 
324        return (XCN) super.insertRepetition(8, rep);
325    }
326
327
328    /**
329     * Removes a repetition of
330     * PR1-8: "Anesthesiologist" at a specific index
331     *
332     * @param rep The repetition index (0-indexed)
333     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
334     */
335    public XCN removeAnesthesiologist(int rep) throws HL7Exception { 
336        return (XCN) super.removeRepetition(8, rep);
337    }
338
339
340    /**
341     * Removes a repetition of
342     * PR1-8: "Anesthesiologist" at a specific index
343     *
344     * @param rep The repetition index (0-indexed)
345     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
346     */
347    public XCN removePr18_Anesthesiologist(int rep) throws HL7Exception { 
348        return (XCN) super.removeRepetition(8, rep);
349    }
350
351
352
353
354    /**
355     * Returns
356     * PR1-9: "Anesthesia Code" - creates it if necessary
357     */
358    public IS getAnesthesiaCode() { 
359                IS retVal = this.getTypedField(9, 0);
360                return retVal;
361    }
362    
363    /**
364     * Returns
365     * PR1-9: "Anesthesia Code" - creates it if necessary
366     */
367    public IS getPr19_AnesthesiaCode() { 
368                IS retVal = this.getTypedField(9, 0);
369                return retVal;
370    }
371
372
373
374    /**
375     * Returns
376     * PR1-10: "Anesthesia Minutes" - creates it if necessary
377     */
378    public NM getAnesthesiaMinutes() { 
379                NM retVal = this.getTypedField(10, 0);
380                return retVal;
381    }
382    
383    /**
384     * Returns
385     * PR1-10: "Anesthesia Minutes" - creates it if necessary
386     */
387    public NM getPr110_AnesthesiaMinutes() { 
388                NM retVal = this.getTypedField(10, 0);
389                return retVal;
390    }
391
392
393    /**
394     * Returns all repetitions of Surgeon (PR1-11).
395     */
396    public XCN[] getSurgeon() {
397        XCN[] retVal = this.getTypedField(11, new XCN[0]);
398        return retVal;
399    }
400
401
402    /**
403     * Returns all repetitions of Surgeon (PR1-11).
404     */
405    public XCN[] getPr111_Surgeon() {
406        XCN[] retVal = this.getTypedField(11, new XCN[0]);
407        return retVal;
408    }
409
410
411    /**
412     * Returns a count of the current number of repetitions of Surgeon (PR1-11).
413     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
414     * it will return zero.
415     */
416    public int getSurgeonReps() {
417        return this.getReps(11);
418    }
419
420
421    /**
422     * Returns a specific repetition of
423     * PR1-11: "Surgeon" - creates it if necessary
424     *
425     * @param rep The repetition index (0-indexed)
426     */
427    public XCN getSurgeon(int rep) { 
428                XCN retVal = this.getTypedField(11, rep);
429                return retVal;
430    }
431
432    /**
433     * Returns a specific repetition of
434     * PR1-11: "Surgeon" - creates it if necessary
435     *
436     * @param rep The repetition index (0-indexed)
437     */
438    public XCN getPr111_Surgeon(int rep) { 
439                XCN retVal = this.getTypedField(11, rep);
440                return retVal;
441    }
442
443    /**
444     * Returns a count of the current number of repetitions of Surgeon (PR1-11).
445     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
446     * it will return zero.
447     */
448    public int getPr111_SurgeonReps() {
449        return this.getReps(11);
450    }
451
452
453    /**
454     * Inserts a repetition of
455     * PR1-11: "Surgeon" at a specific index
456     *
457     * @param rep The repetition index (0-indexed)
458     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
459     */
460    public XCN insertSurgeon(int rep) throws HL7Exception { 
461        return (XCN) super.insertRepetition(11, rep);
462    }
463
464
465    /**
466     * Inserts a repetition of
467     * PR1-11: "Surgeon" at a specific index
468     *
469     * @param rep The repetition index (0-indexed)
470     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
471     */
472    public XCN insertPr111_Surgeon(int rep) throws HL7Exception { 
473        return (XCN) super.insertRepetition(11, rep);
474    }
475
476
477    /**
478     * Removes a repetition of
479     * PR1-11: "Surgeon" at a specific index
480     *
481     * @param rep The repetition index (0-indexed)
482     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
483     */
484    public XCN removeSurgeon(int rep) throws HL7Exception { 
485        return (XCN) super.removeRepetition(11, rep);
486    }
487
488
489    /**
490     * Removes a repetition of
491     * PR1-11: "Surgeon" at a specific index
492     *
493     * @param rep The repetition index (0-indexed)
494     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
495     */
496    public XCN removePr111_Surgeon(int rep) throws HL7Exception { 
497        return (XCN) super.removeRepetition(11, rep);
498    }
499
500
501
502    /**
503     * Returns all repetitions of Procedure Practitioner (PR1-12).
504     */
505    public XCN[] getProcedurePractitioner() {
506        XCN[] retVal = this.getTypedField(12, new XCN[0]);
507        return retVal;
508    }
509
510
511    /**
512     * Returns all repetitions of Procedure Practitioner (PR1-12).
513     */
514    public XCN[] getPr112_ProcedurePractitioner() {
515        XCN[] retVal = this.getTypedField(12, new XCN[0]);
516        return retVal;
517    }
518
519
520    /**
521     * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12).
522     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
523     * it will return zero.
524     */
525    public int getProcedurePractitionerReps() {
526        return this.getReps(12);
527    }
528
529
530    /**
531     * Returns a specific repetition of
532     * PR1-12: "Procedure Practitioner" - creates it if necessary
533     *
534     * @param rep The repetition index (0-indexed)
535     */
536    public XCN getProcedurePractitioner(int rep) { 
537                XCN retVal = this.getTypedField(12, rep);
538                return retVal;
539    }
540
541    /**
542     * Returns a specific repetition of
543     * PR1-12: "Procedure Practitioner" - creates it if necessary
544     *
545     * @param rep The repetition index (0-indexed)
546     */
547    public XCN getPr112_ProcedurePractitioner(int rep) { 
548                XCN retVal = this.getTypedField(12, rep);
549                return retVal;
550    }
551
552    /**
553     * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12).
554     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
555     * it will return zero.
556     */
557    public int getPr112_ProcedurePractitionerReps() {
558        return this.getReps(12);
559    }
560
561
562    /**
563     * Inserts a repetition of
564     * PR1-12: "Procedure Practitioner" at a specific index
565     *
566     * @param rep The repetition index (0-indexed)
567     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
568     */
569    public XCN insertProcedurePractitioner(int rep) throws HL7Exception { 
570        return (XCN) super.insertRepetition(12, rep);
571    }
572
573
574    /**
575     * Inserts a repetition of
576     * PR1-12: "Procedure Practitioner" at a specific index
577     *
578     * @param rep The repetition index (0-indexed)
579     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
580     */
581    public XCN insertPr112_ProcedurePractitioner(int rep) throws HL7Exception { 
582        return (XCN) super.insertRepetition(12, rep);
583    }
584
585
586    /**
587     * Removes a repetition of
588     * PR1-12: "Procedure Practitioner" at a specific index
589     *
590     * @param rep The repetition index (0-indexed)
591     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
592     */
593    public XCN removeProcedurePractitioner(int rep) throws HL7Exception { 
594        return (XCN) super.removeRepetition(12, rep);
595    }
596
597
598    /**
599     * Removes a repetition of
600     * PR1-12: "Procedure Practitioner" at a specific index
601     *
602     * @param rep The repetition index (0-indexed)
603     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
604     */
605    public XCN removePr112_ProcedurePractitioner(int rep) throws HL7Exception { 
606        return (XCN) super.removeRepetition(12, rep);
607    }
608
609
610
611
612    /**
613     * Returns
614     * PR1-13: "Consent Code" - creates it if necessary
615     */
616    public CE getConsentCode() { 
617                CE retVal = this.getTypedField(13, 0);
618                return retVal;
619    }
620    
621    /**
622     * Returns
623     * PR1-13: "Consent Code" - creates it if necessary
624     */
625    public CE getPr113_ConsentCode() { 
626                CE retVal = this.getTypedField(13, 0);
627                return retVal;
628    }
629
630
631
632    /**
633     * Returns
634     * PR1-14: "Procedure Priority" - creates it if necessary
635     */
636    public NM getProcedurePriority() { 
637                NM retVal = this.getTypedField(14, 0);
638                return retVal;
639    }
640    
641    /**
642     * Returns
643     * PR1-14: "Procedure Priority" - creates it if necessary
644     */
645    public NM getPr114_ProcedurePriority() { 
646                NM retVal = this.getTypedField(14, 0);
647                return retVal;
648    }
649
650
651
652    /**
653     * Returns
654     * PR1-15: "Associated Diagnosis Code" - creates it if necessary
655     */
656    public CE getAssociatedDiagnosisCode() { 
657                CE retVal = this.getTypedField(15, 0);
658                return retVal;
659    }
660    
661    /**
662     * Returns
663     * PR1-15: "Associated Diagnosis Code" - creates it if necessary
664     */
665    public CE getPr115_AssociatedDiagnosisCode() { 
666                CE retVal = this.getTypedField(15, 0);
667                return retVal;
668    }
669
670
671    /**
672     * Returns all repetitions of Procedure Code Modifier (PR1-16).
673     */
674    public CE[] getProcedureCodeModifier() {
675        CE[] retVal = this.getTypedField(16, new CE[0]);
676        return retVal;
677    }
678
679
680    /**
681     * Returns all repetitions of Procedure Code Modifier (PR1-16).
682     */
683    public CE[] getPr116_ProcedureCodeModifier() {
684        CE[] retVal = this.getTypedField(16, new CE[0]);
685        return retVal;
686    }
687
688
689    /**
690     * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16).
691     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
692     * it will return zero.
693     */
694    public int getProcedureCodeModifierReps() {
695        return this.getReps(16);
696    }
697
698
699    /**
700     * Returns a specific repetition of
701     * PR1-16: "Procedure Code Modifier" - creates it if necessary
702     *
703     * @param rep The repetition index (0-indexed)
704     */
705    public CE getProcedureCodeModifier(int rep) { 
706                CE retVal = this.getTypedField(16, rep);
707                return retVal;
708    }
709
710    /**
711     * Returns a specific repetition of
712     * PR1-16: "Procedure Code Modifier" - creates it if necessary
713     *
714     * @param rep The repetition index (0-indexed)
715     */
716    public CE getPr116_ProcedureCodeModifier(int rep) { 
717                CE retVal = this.getTypedField(16, rep);
718                return retVal;
719    }
720
721    /**
722     * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16).
723     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
724     * it will return zero.
725     */
726    public int getPr116_ProcedureCodeModifierReps() {
727        return this.getReps(16);
728    }
729
730
731    /**
732     * Inserts a repetition of
733     * PR1-16: "Procedure Code Modifier" at a specific index
734     *
735     * @param rep The repetition index (0-indexed)
736     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
737     */
738    public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 
739        return (CE) super.insertRepetition(16, rep);
740    }
741
742
743    /**
744     * Inserts a repetition of
745     * PR1-16: "Procedure Code Modifier" 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 CE insertPr116_ProcedureCodeModifier(int rep) throws HL7Exception { 
751        return (CE) super.insertRepetition(16, rep);
752    }
753
754
755    /**
756     * Removes a repetition of
757     * PR1-16: "Procedure Code Modifier" 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 CE removeProcedureCodeModifier(int rep) throws HL7Exception { 
763        return (CE) super.removeRepetition(16, rep);
764    }
765
766
767    /**
768     * Removes a repetition of
769     * PR1-16: "Procedure Code Modifier" 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 CE removePr116_ProcedureCodeModifier(int rep) throws HL7Exception { 
775        return (CE) super.removeRepetition(16, rep);
776    }
777
778
779
780
781
782
783    /** {@inheritDoc} */   
784    protected Type createNewTypeWithoutReflection(int field) {
785       switch (field) {
786          case 0: return new SI(getMessage());
787          case 1: return new IS(getMessage(), new Integer( 89 ));
788          case 2: return new CE(getMessage());
789          case 3: return new ST(getMessage());
790          case 4: return new TS(getMessage());
791          case 5: return new IS(getMessage(), new Integer( 230 ));
792          case 6: return new NM(getMessage());
793          case 7: return new XCN(getMessage());
794          case 8: return new IS(getMessage(), new Integer( 19 ));
795          case 9: return new NM(getMessage());
796          case 10: return new XCN(getMessage());
797          case 11: return new XCN(getMessage());
798          case 12: return new CE(getMessage());
799          case 13: return new NM(getMessage());
800          case 14: return new CE(getMessage());
801          case 15: return new CE(getMessage());
802          default: return null;
803       }
804   }
805
806
807}
808