001/*
002 * This class is an auto-generated source file for a HAPI
003 * HL7 v2.x standard structure class.
004 *
005 * For more information, visit: http://hl7api.sourceforge.net/
006 * 
007 * The contents of this file are subject to the Mozilla Public License Version 1.1 
008 * (the "License"); you may not use this file except in compliance with the License. 
009 * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
010 * Software distributed under the License is distributed on an "AS IS" basis, 
011 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 
012 * specific language governing rights and limitations under the License. 
013 * 
014 * The Original Code is "[file_name]".  Description: 
015 * "[one_line_description]" 
016 * 
017 * The Initial Developer of the Original Code is University Health Network. Copyright (C) 
018 * 2012.  All Rights Reserved. 
019 * 
020 * Contributor(s): ______________________________________. 
021 * 
022 * Alternatively, the contents of this file may be used under the terms of the 
023 * GNU General Public License (the  "GPL"), in which case the provisions of the GPL are 
024 * applicable instead of those above.  If you wish to allow use of your version of this 
025 * file only under the terms of the GPL and not to allow others to use your version 
026 * of this file under the MPL, indicate your decision by deleting  the provisions above 
027 * and replace  them with the notice and other provisions required by the GPL License.  
028 * If you do not delete the provisions above, a recipient may use your version of 
029 * this file under either the MPL or the GPL. 
030 * 
031 */
032
033
034package ca.uhn.hl7v2.model.v24.segment;
035
036// import ca.uhn.hl7v2.model.v24.group.*;
037import ca.uhn.hl7v2.model.v24.datatype.*;
038import ca.uhn.hl7v2.HL7Exception;
039import ca.uhn.hl7v2.parser.ModelClassFactory;
040import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
041import ca.uhn.hl7v2.model.AbstractMessage;
042import ca.uhn.hl7v2.model.Group;
043import ca.uhn.hl7v2.model.Type;
044import ca.uhn.hl7v2.model.AbstractSegment;
045import ca.uhn.hl7v2.model.Varies;
046
047
048/**
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 * </ul>
071 */
072@SuppressWarnings("unused")
073public class PR1 extends AbstractSegment {
074
075    /** 
076     * Creates a new PR1 segment
077     */
078    public PR1(Group parent, ModelClassFactory factory) {
079       super(parent, factory);
080       init(factory);
081    }
082
083    private void init(ModelClassFactory factory) {
084       try {
085                                  this.add(SI.class, true, 1, 4, new Object[]{ getMessage() }, "Set ID - PR1");
086                                              this.add(IS.class, false, 1, 3, new Object[]{ getMessage(), new Integer(89) }, "Procedure Coding Method");
087                                  this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Procedure Code");
088                                  this.add(ST.class, false, 1, 40, new Object[]{ getMessage() }, "Procedure Description");
089                                  this.add(TS.class, true, 1, 26, new Object[]{ getMessage() }, "Procedure Date/Time");
090                                              this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(230) }, "Procedure Functional Type");
091                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Procedure Minutes");
092                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Anesthesiologist");
093                                              this.add(IS.class, false, 1, 2, new Object[]{ getMessage(), new Integer(19) }, "Anesthesia Code");
094                                  this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Anesthesia Minutes");
095                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Surgeon");
096                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Procedure Practitioner");
097                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Consent Code");
098                                              this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(418) }, "Procedure Priority");
099                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Associated Diagnosis Code");
100                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Procedure Code Modifier");
101                                              this.add(IS.class, false, 1, 20, new Object[]{ getMessage(), new Integer(416) }, "Procedure DRG Type");
102                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Tissue Type Code");
103       } catch(HL7Exception e) {
104          log.error("Unexpected error creating PR1 - this is probably a bug in the source code generator.", e);
105       }
106    }
107
108
109
110    /**
111     * Returns
112     * PR1-1: "Set ID - PR1" - creates it if necessary
113     */
114    public SI getSetIDPR1() { 
115                SI retVal = this.getTypedField(1, 0);
116                return retVal;
117    }
118    
119    /**
120     * Returns
121     * PR1-1: "Set ID - PR1" - creates it if necessary
122     */
123    public SI getPr11_SetIDPR1() { 
124                SI retVal = this.getTypedField(1, 0);
125                return retVal;
126    }
127
128
129
130    /**
131     * Returns
132     * PR1-2: "Procedure Coding Method" - creates it if necessary
133     */
134    public IS getProcedureCodingMethod() { 
135                IS retVal = this.getTypedField(2, 0);
136                return retVal;
137    }
138    
139    /**
140     * Returns
141     * PR1-2: "Procedure Coding Method" - creates it if necessary
142     */
143    public IS getPr12_ProcedureCodingMethod() { 
144                IS retVal = this.getTypedField(2, 0);
145                return retVal;
146    }
147
148
149
150    /**
151     * Returns
152     * PR1-3: "Procedure Code" - creates it if necessary
153     */
154    public CE getProcedureCode() { 
155                CE retVal = this.getTypedField(3, 0);
156                return retVal;
157    }
158    
159    /**
160     * Returns
161     * PR1-3: "Procedure Code" - creates it if necessary
162     */
163    public CE getPr13_ProcedureCode() { 
164                CE retVal = this.getTypedField(3, 0);
165                return retVal;
166    }
167
168
169
170    /**
171     * Returns
172     * PR1-4: "Procedure Description" - creates it if necessary
173     */
174    public ST getProcedureDescription() { 
175                ST retVal = this.getTypedField(4, 0);
176                return retVal;
177    }
178    
179    /**
180     * Returns
181     * PR1-4: "Procedure Description" - creates it if necessary
182     */
183    public ST getPr14_ProcedureDescription() { 
184                ST retVal = this.getTypedField(4, 0);
185                return retVal;
186    }
187
188
189
190    /**
191     * Returns
192     * PR1-5: "Procedure Date/Time" - creates it if necessary
193     */
194    public TS getProcedureDateTime() { 
195                TS retVal = this.getTypedField(5, 0);
196                return retVal;
197    }
198    
199    /**
200     * Returns
201     * PR1-5: "Procedure Date/Time" - creates it if necessary
202     */
203    public TS getPr15_ProcedureDateTime() { 
204                TS retVal = this.getTypedField(5, 0);
205                return retVal;
206    }
207
208
209
210    /**
211     * Returns
212     * PR1-6: "Procedure Functional Type" - creates it if necessary
213     */
214    public IS getProcedureFunctionalType() { 
215                IS retVal = this.getTypedField(6, 0);
216                return retVal;
217    }
218    
219    /**
220     * Returns
221     * PR1-6: "Procedure Functional Type" - creates it if necessary
222     */
223    public IS getPr16_ProcedureFunctionalType() { 
224                IS retVal = this.getTypedField(6, 0);
225                return retVal;
226    }
227
228
229
230    /**
231     * Returns
232     * PR1-7: "Procedure Minutes" - creates it if necessary
233     */
234    public NM getProcedureMinutes() { 
235                NM retVal = this.getTypedField(7, 0);
236                return retVal;
237    }
238    
239    /**
240     * Returns
241     * PR1-7: "Procedure Minutes" - creates it if necessary
242     */
243    public NM getPr17_ProcedureMinutes() { 
244                NM retVal = this.getTypedField(7, 0);
245                return retVal;
246    }
247
248
249    /**
250     * Returns all repetitions of Anesthesiologist (PR1-8).
251     */
252    public XCN[] getAnesthesiologist() {
253        XCN[] retVal = this.getTypedField(8, new XCN[0]);
254        return retVal;
255    }
256
257
258    /**
259     * Returns all repetitions of Anesthesiologist (PR1-8).
260     */
261    public XCN[] getPr18_Anesthesiologist() {
262        XCN[] retVal = this.getTypedField(8, new XCN[0]);
263        return retVal;
264    }
265
266
267    /**
268     * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8).
269     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
270     * it will return zero.
271     */
272    public int getAnesthesiologistReps() {
273        return this.getReps(8);
274    }
275
276
277    /**
278     * Returns a specific repetition of
279     * PR1-8: "Anesthesiologist" - creates it if necessary
280     *
281     * @param rep The repetition index (0-indexed)
282     */
283    public XCN getAnesthesiologist(int rep) { 
284                XCN retVal = this.getTypedField(8, rep);
285                return retVal;
286    }
287
288    /**
289     * Returns a specific repetition of
290     * PR1-8: "Anesthesiologist" - creates it if necessary
291     *
292     * @param rep The repetition index (0-indexed)
293     */
294    public XCN getPr18_Anesthesiologist(int rep) { 
295                XCN retVal = this.getTypedField(8, rep);
296                return retVal;
297    }
298
299    /**
300     * Returns a count of the current number of repetitions of Anesthesiologist (PR1-8).
301     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
302     * it will return zero.
303     */
304    public int getPr18_AnesthesiologistReps() {
305        return this.getReps(8);
306    }
307
308
309    /**
310     * Inserts a repetition of
311     * PR1-8: "Anesthesiologist" at a specific index
312     *
313     * @param rep The repetition index (0-indexed)
314     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
315     */
316    public XCN insertAnesthesiologist(int rep) throws HL7Exception { 
317        return (XCN) super.insertRepetition(8, rep);
318    }
319
320
321    /**
322     * Inserts a repetition of
323     * PR1-8: "Anesthesiologist" at a specific index
324     *
325     * @param rep The repetition index (0-indexed)
326     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
327     */
328    public XCN insertPr18_Anesthesiologist(int rep) throws HL7Exception { 
329        return (XCN) super.insertRepetition(8, rep);
330    }
331
332
333    /**
334     * Removes a repetition of
335     * PR1-8: "Anesthesiologist" at a specific index
336     *
337     * @param rep The repetition index (0-indexed)
338     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
339     */
340    public XCN removeAnesthesiologist(int rep) throws HL7Exception { 
341        return (XCN) super.removeRepetition(8, rep);
342    }
343
344
345    /**
346     * Removes a repetition of
347     * PR1-8: "Anesthesiologist" at a specific index
348     *
349     * @param rep The repetition index (0-indexed)
350     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
351     */
352    public XCN removePr18_Anesthesiologist(int rep) throws HL7Exception { 
353        return (XCN) super.removeRepetition(8, rep);
354    }
355
356
357
358
359    /**
360     * Returns
361     * PR1-9: "Anesthesia Code" - creates it if necessary
362     */
363    public IS getAnesthesiaCode() { 
364                IS retVal = this.getTypedField(9, 0);
365                return retVal;
366    }
367    
368    /**
369     * Returns
370     * PR1-9: "Anesthesia Code" - creates it if necessary
371     */
372    public IS getPr19_AnesthesiaCode() { 
373                IS retVal = this.getTypedField(9, 0);
374                return retVal;
375    }
376
377
378
379    /**
380     * Returns
381     * PR1-10: "Anesthesia Minutes" - creates it if necessary
382     */
383    public NM getAnesthesiaMinutes() { 
384                NM retVal = this.getTypedField(10, 0);
385                return retVal;
386    }
387    
388    /**
389     * Returns
390     * PR1-10: "Anesthesia Minutes" - creates it if necessary
391     */
392    public NM getPr110_AnesthesiaMinutes() { 
393                NM retVal = this.getTypedField(10, 0);
394                return retVal;
395    }
396
397
398    /**
399     * Returns all repetitions of Surgeon (PR1-11).
400     */
401    public XCN[] getSurgeon() {
402        XCN[] retVal = this.getTypedField(11, new XCN[0]);
403        return retVal;
404    }
405
406
407    /**
408     * Returns all repetitions of Surgeon (PR1-11).
409     */
410    public XCN[] getPr111_Surgeon() {
411        XCN[] retVal = this.getTypedField(11, new XCN[0]);
412        return retVal;
413    }
414
415
416    /**
417     * Returns a count of the current number of repetitions of Surgeon (PR1-11).
418     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
419     * it will return zero.
420     */
421    public int getSurgeonReps() {
422        return this.getReps(11);
423    }
424
425
426    /**
427     * Returns a specific repetition of
428     * PR1-11: "Surgeon" - creates it if necessary
429     *
430     * @param rep The repetition index (0-indexed)
431     */
432    public XCN getSurgeon(int rep) { 
433                XCN retVal = this.getTypedField(11, rep);
434                return retVal;
435    }
436
437    /**
438     * Returns a specific repetition of
439     * PR1-11: "Surgeon" - creates it if necessary
440     *
441     * @param rep The repetition index (0-indexed)
442     */
443    public XCN getPr111_Surgeon(int rep) { 
444                XCN retVal = this.getTypedField(11, rep);
445                return retVal;
446    }
447
448    /**
449     * Returns a count of the current number of repetitions of Surgeon (PR1-11).
450     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
451     * it will return zero.
452     */
453    public int getPr111_SurgeonReps() {
454        return this.getReps(11);
455    }
456
457
458    /**
459     * Inserts a repetition of
460     * PR1-11: "Surgeon" at a specific index
461     *
462     * @param rep The repetition index (0-indexed)
463     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
464     */
465    public XCN insertSurgeon(int rep) throws HL7Exception { 
466        return (XCN) super.insertRepetition(11, rep);
467    }
468
469
470    /**
471     * Inserts a repetition of
472     * PR1-11: "Surgeon" at a specific index
473     *
474     * @param rep The repetition index (0-indexed)
475     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
476     */
477    public XCN insertPr111_Surgeon(int rep) throws HL7Exception { 
478        return (XCN) super.insertRepetition(11, rep);
479    }
480
481
482    /**
483     * Removes a repetition of
484     * PR1-11: "Surgeon" at a specific index
485     *
486     * @param rep The repetition index (0-indexed)
487     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
488     */
489    public XCN removeSurgeon(int rep) throws HL7Exception { 
490        return (XCN) super.removeRepetition(11, rep);
491    }
492
493
494    /**
495     * Removes a repetition of
496     * PR1-11: "Surgeon" at a specific index
497     *
498     * @param rep The repetition index (0-indexed)
499     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
500     */
501    public XCN removePr111_Surgeon(int rep) throws HL7Exception { 
502        return (XCN) super.removeRepetition(11, rep);
503    }
504
505
506
507    /**
508     * Returns all repetitions of Procedure Practitioner (PR1-12).
509     */
510    public XCN[] getProcedurePractitioner() {
511        XCN[] retVal = this.getTypedField(12, new XCN[0]);
512        return retVal;
513    }
514
515
516    /**
517     * Returns all repetitions of Procedure Practitioner (PR1-12).
518     */
519    public XCN[] getPr112_ProcedurePractitioner() {
520        XCN[] retVal = this.getTypedField(12, new XCN[0]);
521        return retVal;
522    }
523
524
525    /**
526     * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12).
527     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
528     * it will return zero.
529     */
530    public int getProcedurePractitionerReps() {
531        return this.getReps(12);
532    }
533
534
535    /**
536     * Returns a specific repetition of
537     * PR1-12: "Procedure Practitioner" - creates it if necessary
538     *
539     * @param rep The repetition index (0-indexed)
540     */
541    public XCN getProcedurePractitioner(int rep) { 
542                XCN retVal = this.getTypedField(12, rep);
543                return retVal;
544    }
545
546    /**
547     * Returns a specific repetition of
548     * PR1-12: "Procedure Practitioner" - creates it if necessary
549     *
550     * @param rep The repetition index (0-indexed)
551     */
552    public XCN getPr112_ProcedurePractitioner(int rep) { 
553                XCN retVal = this.getTypedField(12, rep);
554                return retVal;
555    }
556
557    /**
558     * Returns a count of the current number of repetitions of Procedure Practitioner (PR1-12).
559     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
560     * it will return zero.
561     */
562    public int getPr112_ProcedurePractitionerReps() {
563        return this.getReps(12);
564    }
565
566
567    /**
568     * Inserts a repetition of
569     * PR1-12: "Procedure Practitioner" at a specific index
570     *
571     * @param rep The repetition index (0-indexed)
572     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
573     */
574    public XCN insertProcedurePractitioner(int rep) throws HL7Exception { 
575        return (XCN) super.insertRepetition(12, rep);
576    }
577
578
579    /**
580     * Inserts a repetition of
581     * PR1-12: "Procedure Practitioner" at a specific index
582     *
583     * @param rep The repetition index (0-indexed)
584     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
585     */
586    public XCN insertPr112_ProcedurePractitioner(int rep) throws HL7Exception { 
587        return (XCN) super.insertRepetition(12, rep);
588    }
589
590
591    /**
592     * Removes a repetition of
593     * PR1-12: "Procedure Practitioner" at a specific index
594     *
595     * @param rep The repetition index (0-indexed)
596     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
597     */
598    public XCN removeProcedurePractitioner(int rep) throws HL7Exception { 
599        return (XCN) super.removeRepetition(12, rep);
600    }
601
602
603    /**
604     * Removes a repetition of
605     * PR1-12: "Procedure Practitioner" at a specific index
606     *
607     * @param rep The repetition index (0-indexed)
608     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
609     */
610    public XCN removePr112_ProcedurePractitioner(int rep) throws HL7Exception { 
611        return (XCN) super.removeRepetition(12, rep);
612    }
613
614
615
616
617    /**
618     * Returns
619     * PR1-13: "Consent Code" - creates it if necessary
620     */
621    public CE getConsentCode() { 
622                CE retVal = this.getTypedField(13, 0);
623                return retVal;
624    }
625    
626    /**
627     * Returns
628     * PR1-13: "Consent Code" - creates it if necessary
629     */
630    public CE getPr113_ConsentCode() { 
631                CE retVal = this.getTypedField(13, 0);
632                return retVal;
633    }
634
635
636
637    /**
638     * Returns
639     * PR1-14: "Procedure Priority" - creates it if necessary
640     */
641    public ID getProcedurePriority() { 
642                ID retVal = this.getTypedField(14, 0);
643                return retVal;
644    }
645    
646    /**
647     * Returns
648     * PR1-14: "Procedure Priority" - creates it if necessary
649     */
650    public ID getPr114_ProcedurePriority() { 
651                ID retVal = this.getTypedField(14, 0);
652                return retVal;
653    }
654
655
656
657    /**
658     * Returns
659     * PR1-15: "Associated Diagnosis Code" - creates it if necessary
660     */
661    public CE getAssociatedDiagnosisCode() { 
662                CE retVal = this.getTypedField(15, 0);
663                return retVal;
664    }
665    
666    /**
667     * Returns
668     * PR1-15: "Associated Diagnosis Code" - creates it if necessary
669     */
670    public CE getPr115_AssociatedDiagnosisCode() { 
671                CE retVal = this.getTypedField(15, 0);
672                return retVal;
673    }
674
675
676    /**
677     * Returns all repetitions of Procedure Code Modifier (PR1-16).
678     */
679    public CE[] getProcedureCodeModifier() {
680        CE[] retVal = this.getTypedField(16, new CE[0]);
681        return retVal;
682    }
683
684
685    /**
686     * Returns all repetitions of Procedure Code Modifier (PR1-16).
687     */
688    public CE[] getPr116_ProcedureCodeModifier() {
689        CE[] retVal = this.getTypedField(16, new CE[0]);
690        return retVal;
691    }
692
693
694    /**
695     * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16).
696     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
697     * it will return zero.
698     */
699    public int getProcedureCodeModifierReps() {
700        return this.getReps(16);
701    }
702
703
704    /**
705     * Returns a specific repetition of
706     * PR1-16: "Procedure Code Modifier" - creates it if necessary
707     *
708     * @param rep The repetition index (0-indexed)
709     */
710    public CE getProcedureCodeModifier(int rep) { 
711                CE retVal = this.getTypedField(16, rep);
712                return retVal;
713    }
714
715    /**
716     * Returns a specific repetition of
717     * PR1-16: "Procedure Code Modifier" - creates it if necessary
718     *
719     * @param rep The repetition index (0-indexed)
720     */
721    public CE getPr116_ProcedureCodeModifier(int rep) { 
722                CE retVal = this.getTypedField(16, rep);
723                return retVal;
724    }
725
726    /**
727     * Returns a count of the current number of repetitions of Procedure Code Modifier (PR1-16).
728     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
729     * it will return zero.
730     */
731    public int getPr116_ProcedureCodeModifierReps() {
732        return this.getReps(16);
733    }
734
735
736    /**
737     * Inserts a repetition of
738     * PR1-16: "Procedure Code Modifier" at a specific index
739     *
740     * @param rep The repetition index (0-indexed)
741     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
742     */
743    public CE insertProcedureCodeModifier(int rep) throws HL7Exception { 
744        return (CE) super.insertRepetition(16, rep);
745    }
746
747
748    /**
749     * Inserts a repetition of
750     * PR1-16: "Procedure Code Modifier" at a specific index
751     *
752     * @param rep The repetition index (0-indexed)
753     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
754     */
755    public CE insertPr116_ProcedureCodeModifier(int rep) throws HL7Exception { 
756        return (CE) super.insertRepetition(16, rep);
757    }
758
759
760    /**
761     * Removes a repetition of
762     * PR1-16: "Procedure Code Modifier" at a specific index
763     *
764     * @param rep The repetition index (0-indexed)
765     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
766     */
767    public CE removeProcedureCodeModifier(int rep) throws HL7Exception { 
768        return (CE) super.removeRepetition(16, rep);
769    }
770
771
772    /**
773     * Removes a repetition of
774     * PR1-16: "Procedure Code Modifier" at a specific index
775     *
776     * @param rep The repetition index (0-indexed)
777     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
778     */
779    public CE removePr116_ProcedureCodeModifier(int rep) throws HL7Exception { 
780        return (CE) super.removeRepetition(16, rep);
781    }
782
783
784
785
786    /**
787     * Returns
788     * PR1-17: "Procedure DRG Type" - creates it if necessary
789     */
790    public IS getProcedureDRGType() { 
791                IS retVal = this.getTypedField(17, 0);
792                return retVal;
793    }
794    
795    /**
796     * Returns
797     * PR1-17: "Procedure DRG Type" - creates it if necessary
798     */
799    public IS getPr117_ProcedureDRGType() { 
800                IS retVal = this.getTypedField(17, 0);
801                return retVal;
802    }
803
804
805    /**
806     * Returns all repetitions of Tissue Type Code (PR1-18).
807     */
808    public CE[] getTissueTypeCode() {
809        CE[] retVal = this.getTypedField(18, new CE[0]);
810        return retVal;
811    }
812
813
814    /**
815     * Returns all repetitions of Tissue Type Code (PR1-18).
816     */
817    public CE[] getPr118_TissueTypeCode() {
818        CE[] retVal = this.getTypedField(18, new CE[0]);
819        return retVal;
820    }
821
822
823    /**
824     * Returns a count of the current number of repetitions of Tissue Type Code (PR1-18).
825     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
826     * it will return zero.
827     */
828    public int getTissueTypeCodeReps() {
829        return this.getReps(18);
830    }
831
832
833    /**
834     * Returns a specific repetition of
835     * PR1-18: "Tissue Type Code" - creates it if necessary
836     *
837     * @param rep The repetition index (0-indexed)
838     */
839    public CE getTissueTypeCode(int rep) { 
840                CE retVal = this.getTypedField(18, rep);
841                return retVal;
842    }
843
844    /**
845     * Returns a specific repetition of
846     * PR1-18: "Tissue Type Code" - creates it if necessary
847     *
848     * @param rep The repetition index (0-indexed)
849     */
850    public CE getPr118_TissueTypeCode(int rep) { 
851                CE retVal = this.getTypedField(18, rep);
852                return retVal;
853    }
854
855    /**
856     * Returns a count of the current number of repetitions of Tissue Type Code (PR1-18).
857     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
858     * it will return zero.
859     */
860    public int getPr118_TissueTypeCodeReps() {
861        return this.getReps(18);
862    }
863
864
865    /**
866     * Inserts a repetition of
867     * PR1-18: "Tissue Type Code" at a specific index
868     *
869     * @param rep The repetition index (0-indexed)
870     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
871     */
872    public CE insertTissueTypeCode(int rep) throws HL7Exception { 
873        return (CE) super.insertRepetition(18, rep);
874    }
875
876
877    /**
878     * Inserts a repetition of
879     * PR1-18: "Tissue Type Code" at a specific index
880     *
881     * @param rep The repetition index (0-indexed)
882     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
883     */
884    public CE insertPr118_TissueTypeCode(int rep) throws HL7Exception { 
885        return (CE) super.insertRepetition(18, rep);
886    }
887
888
889    /**
890     * Removes a repetition of
891     * PR1-18: "Tissue Type Code" at a specific index
892     *
893     * @param rep The repetition index (0-indexed)
894     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
895     */
896    public CE removeTissueTypeCode(int rep) throws HL7Exception { 
897        return (CE) super.removeRepetition(18, rep);
898    }
899
900
901    /**
902     * Removes a repetition of
903     * PR1-18: "Tissue Type Code" at a specific index
904     *
905     * @param rep The repetition index (0-indexed)
906     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
907     */
908    public CE removePr118_TissueTypeCode(int rep) throws HL7Exception { 
909        return (CE) super.removeRepetition(18, rep);
910    }
911
912
913
914
915
916
917    /** {@inheritDoc} */   
918    protected Type createNewTypeWithoutReflection(int field) {
919       switch (field) {
920          case 0: return new SI(getMessage());
921          case 1: return new IS(getMessage(), new Integer( 89 ));
922          case 2: return new CE(getMessage());
923          case 3: return new ST(getMessage());
924          case 4: return new TS(getMessage());
925          case 5: return new IS(getMessage(), new Integer( 230 ));
926          case 6: return new NM(getMessage());
927          case 7: return new XCN(getMessage());
928          case 8: return new IS(getMessage(), new Integer( 19 ));
929          case 9: return new NM(getMessage());
930          case 10: return new XCN(getMessage());
931          case 11: return new XCN(getMessage());
932          case 12: return new CE(getMessage());
933          case 13: return new ID(getMessage(), new Integer( 418 ));
934          case 14: return new CE(getMessage());
935          case 15: return new CE(getMessage());
936          case 16: return new IS(getMessage(), new Integer( 416 ));
937          case 17: return new CE(getMessage());
938          default: return null;
939       }
940   }
941
942
943}
944