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