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