View Javadoc
1   /*
2    * This class is an auto-generated source file for a HAPI
3    * HL7 v2.x standard structure class.
4    *
5    * For more information, visit: http://hl7api.sourceforge.net/
6    * 
7    * The contents of this file are subject to the Mozilla Public License Version 1.1 
8    * (the "License"); you may not use this file except in compliance with the License. 
9    * You may obtain a copy of the License at http://www.mozilla.org/MPL/ 
10   * Software distributed under the License is distributed on an "AS IS" basis, 
11   * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the 
12   * specific language governing rights and limitations under the License. 
13   * 
14   * The Original Code is "[file_name]".  Description: 
15   * "[one_line_description]" 
16   * 
17   * The Initial Developer of the Original Code is University Health Network. Copyright (C) 
18   * 2012.  All Rights Reserved. 
19   * 
20   * Contributor(s): ______________________________________. 
21   * 
22   * Alternatively, the contents of this file may be used under the terms of the 
23   * GNU General Public License (the  "GPL"), in which case the provisions of the GPL are 
24   * applicable instead of those above.  If you wish to allow use of your version of this 
25   * file only under the terms of the GPL and not to allow others to use your version 
26   * of this file under the MPL, indicate your decision by deleting  the provisions above 
27   * and replace  them with the notice and other provisions required by the GPL License.  
28   * If you do not delete the provisions above, a recipient may use your version of 
29   * this file under either the MPL or the GPL. 
30   * 
31   */
32  
33  
34  package ca.uhn.hl7v2.model.v25.segment;
35  
36  // import ca.uhn.hl7v2.model.v25.group.*;
37  import ca.uhn.hl7v2.model.v25.datatype.*;
38  import ca.uhn.hl7v2.HL7Exception;
39  import ca.uhn.hl7v2.parser.ModelClassFactory;
40  import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
41  import ca.uhn.hl7v2.model.AbstractMessage;
42  import ca.uhn.hl7v2.model.Group;
43  import ca.uhn.hl7v2.model.Type;
44  import ca.uhn.hl7v2.model.AbstractSegment;
45  import ca.uhn.hl7v2.model.Varies;
46  
47  
48  /**
49   *<p>Represents an HL7 TQ1 message segment (Timing/Quantity). 
50   * This segment has the following fields:</p>
51   * <ul>
52       * <li>TQ1-1: Set ID - TQ1 (SI) <b>optional </b>
53       * <li>TQ1-2: Quantity (CQ) <b>optional </b>
54       * <li>TQ1-3: Repeat Pattern (RPT) <b>optional repeating</b>
55       * <li>TQ1-4: Explicit Time (TM) <b>optional repeating</b>
56       * <li>TQ1-5: Relative Time and Units (CQ) <b>optional repeating</b>
57       * <li>TQ1-6: Service Duration (CQ) <b>optional </b>
58       * <li>TQ1-7: Start date/time (TS) <b>optional </b>
59       * <li>TQ1-8: End date/time (TS) <b>optional </b>
60       * <li>TQ1-9: Priority (CWE) <b>optional repeating</b>
61       * <li>TQ1-10: Condition text (TX) <b>optional </b>
62       * <li>TQ1-11: Text instruction (TX) <b>optional </b>
63       * <li>TQ1-12: Conjunction (ID) <b>optional </b>
64       * <li>TQ1-13: Occurrence duration (CQ) <b>optional </b>
65       * <li>TQ1-14: Total occurrence's (NM) <b>optional </b>
66   * </ul>
67   */
68  @SuppressWarnings("unused")
69  public class TQ1 extends AbstractSegment {
70  
71      /** 
72       * Creates a new TQ1 segment
73       */
74      public TQ1(Group parent, ModelClassFactory factory) {
75         super(parent, factory);
76         init(factory);
77      }
78  
79      private void init(ModelClassFactory factory) {
80         try {
81                                    this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - TQ1");
82                                    this.add(CQ.class, false, 1, 20, new Object[]{ getMessage() }, "Quantity");
83                                    this.add(RPT.class, false, 0, 540, new Object[]{ getMessage() }, "Repeat Pattern");
84                                    this.add(TM.class, false, 0, 20, new Object[]{ getMessage() }, "Explicit Time");
85                                    this.add(CQ.class, false, 0, 20, new Object[]{ getMessage() }, "Relative Time and Units");
86                                    this.add(CQ.class, false, 1, 20, new Object[]{ getMessage() }, "Service Duration");
87                                    this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Start date/time");
88                                    this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "End date/time");
89                                    this.add(CWE.class, false, 0, 250, new Object[]{ getMessage() }, "Priority");
90                                    this.add(TX.class, false, 1, 250, new Object[]{ getMessage() }, "Condition text");
91                                    this.add(TX.class, false, 1, 250, new Object[]{ getMessage() }, "Text instruction");
92                                                this.add(ID.class, false, 1, 10, new Object[]{ getMessage(), new Integer(427) }, "Conjunction");
93                                    this.add(CQ.class, false, 1, 20, new Object[]{ getMessage() }, "Occurrence duration");
94                                    this.add(NM.class, false, 1, 10, new Object[]{ getMessage() }, "Total occurrence's");
95         } catch(HL7Exception e) {
96            log.error("Unexpected error creating TQ1 - this is probably a bug in the source code generator.", e);
97         }
98      }
99  
100 
101 
102     /**
103      * Returns
104      * TQ1-1: "Set ID - TQ1" - creates it if necessary
105      */
106     public SI getSetIDTQ1() { 
107 		SI retVal = this.getTypedField(1, 0);
108 		return retVal;
109     }
110     
111     /**
112      * Returns
113      * TQ1-1: "Set ID - TQ1" - creates it if necessary
114      */
115     public SI getTq11_SetIDTQ1() { 
116 		SI retVal = this.getTypedField(1, 0);
117 		return retVal;
118     }
119 
120 
121 
122     /**
123      * Returns
124      * TQ1-2: "Quantity" - creates it if necessary
125      */
126     public CQ getQuantity() { 
127 		CQ retVal = this.getTypedField(2, 0);
128 		return retVal;
129     }
130     
131     /**
132      * Returns
133      * TQ1-2: "Quantity" - creates it if necessary
134      */
135     public CQ getTq12_Quantity() { 
136 		CQ retVal = this.getTypedField(2, 0);
137 		return retVal;
138     }
139 
140 
141     /**
142      * Returns all repetitions of Repeat Pattern (TQ1-3).
143      */
144     public RPT[] getRepeatPattern() {
145     	RPT[] retVal = this.getTypedField(3, new RPT[0]);
146     	return retVal;
147     }
148 
149 
150     /**
151      * Returns all repetitions of Repeat Pattern (TQ1-3).
152      */
153     public RPT[] getTq13_RepeatPattern() {
154     	RPT[] retVal = this.getTypedField(3, new RPT[0]);
155     	return retVal;
156     }
157 
158 
159     /**
160      * Returns a count of the current number of repetitions of Repeat Pattern (TQ1-3).
161      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
162      * it will return zero.
163      */
164     public int getRepeatPatternReps() {
165     	return this.getReps(3);
166     }
167 
168 
169     /**
170      * Returns a specific repetition of
171      * TQ1-3: "Repeat Pattern" - creates it if necessary
172      *
173      * @param rep The repetition index (0-indexed)
174      */
175     public RPT getRepeatPattern(int rep) { 
176 		RPT retVal = this.getTypedField(3, rep);
177 		return retVal;
178     }
179 
180     /**
181      * Returns a specific repetition of
182      * TQ1-3: "Repeat Pattern" - creates it if necessary
183      *
184      * @param rep The repetition index (0-indexed)
185      */
186     public RPT getTq13_RepeatPattern(int rep) { 
187 		RPT retVal = this.getTypedField(3, rep);
188 		return retVal;
189     }
190 
191     /**
192      * Returns a count of the current number of repetitions of Repeat Pattern (TQ1-3).
193      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
194      * it will return zero.
195      */
196     public int getTq13_RepeatPatternReps() {
197     	return this.getReps(3);
198     }
199 
200 
201     /**
202      * Inserts a repetition of
203      * TQ1-3: "Repeat Pattern" at a specific index
204      *
205      * @param rep The repetition index (0-indexed)
206      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
207      */
208     public RPT insertRepeatPattern(int rep) throws HL7Exception { 
209         return (RPT) super.insertRepetition(3, rep);
210     }
211 
212 
213     /**
214      * Inserts a repetition of
215      * TQ1-3: "Repeat Pattern" at a specific index
216      *
217      * @param rep The repetition index (0-indexed)
218      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
219      */
220     public RPT insertTq13_RepeatPattern(int rep) throws HL7Exception { 
221         return (RPT) super.insertRepetition(3, rep);
222     }
223 
224 
225     /**
226      * Removes a repetition of
227      * TQ1-3: "Repeat Pattern" at a specific index
228      *
229      * @param rep The repetition index (0-indexed)
230      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
231      */
232     public RPT removeRepeatPattern(int rep) throws HL7Exception { 
233         return (RPT) super.removeRepetition(3, rep);
234     }
235 
236 
237     /**
238      * Removes a repetition of
239      * TQ1-3: "Repeat Pattern" at a specific index
240      *
241      * @param rep The repetition index (0-indexed)
242      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
243      */
244     public RPT removeTq13_RepeatPattern(int rep) throws HL7Exception { 
245         return (RPT) super.removeRepetition(3, rep);
246     }
247 
248 
249 
250     /**
251      * Returns all repetitions of Explicit Time (TQ1-4).
252      */
253     public TM[] getExplicitTime() {
254     	TM[] retVal = this.getTypedField(4, new TM[0]);
255     	return retVal;
256     }
257 
258 
259     /**
260      * Returns all repetitions of Explicit Time (TQ1-4).
261      */
262     public TM[] getTq14_ExplicitTime() {
263     	TM[] retVal = this.getTypedField(4, new TM[0]);
264     	return retVal;
265     }
266 
267 
268     /**
269      * Returns a count of the current number of repetitions of Explicit Time (TQ1-4).
270      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
271      * it will return zero.
272      */
273     public int getExplicitTimeReps() {
274     	return this.getReps(4);
275     }
276 
277 
278     /**
279      * Returns a specific repetition of
280      * TQ1-4: "Explicit Time" - creates it if necessary
281      *
282      * @param rep The repetition index (0-indexed)
283      */
284     public TM getExplicitTime(int rep) { 
285 		TM retVal = this.getTypedField(4, rep);
286 		return retVal;
287     }
288 
289     /**
290      * Returns a specific repetition of
291      * TQ1-4: "Explicit Time" - creates it if necessary
292      *
293      * @param rep The repetition index (0-indexed)
294      */
295     public TM getTq14_ExplicitTime(int rep) { 
296 		TM retVal = this.getTypedField(4, rep);
297 		return retVal;
298     }
299 
300     /**
301      * Returns a count of the current number of repetitions of Explicit Time (TQ1-4).
302      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
303      * it will return zero.
304      */
305     public int getTq14_ExplicitTimeReps() {
306     	return this.getReps(4);
307     }
308 
309 
310     /**
311      * Inserts a repetition of
312      * TQ1-4: "Explicit Time" at a specific index
313      *
314      * @param rep The repetition index (0-indexed)
315      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
316      */
317     public TM insertExplicitTime(int rep) throws HL7Exception { 
318         return (TM) super.insertRepetition(4, rep);
319     }
320 
321 
322     /**
323      * Inserts a repetition of
324      * TQ1-4: "Explicit Time" at a specific index
325      *
326      * @param rep The repetition index (0-indexed)
327      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
328      */
329     public TM insertTq14_ExplicitTime(int rep) throws HL7Exception { 
330         return (TM) super.insertRepetition(4, rep);
331     }
332 
333 
334     /**
335      * Removes a repetition of
336      * TQ1-4: "Explicit Time" at a specific index
337      *
338      * @param rep The repetition index (0-indexed)
339      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
340      */
341     public TM removeExplicitTime(int rep) throws HL7Exception { 
342         return (TM) super.removeRepetition(4, rep);
343     }
344 
345 
346     /**
347      * Removes a repetition of
348      * TQ1-4: "Explicit Time" at a specific index
349      *
350      * @param rep The repetition index (0-indexed)
351      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
352      */
353     public TM removeTq14_ExplicitTime(int rep) throws HL7Exception { 
354         return (TM) super.removeRepetition(4, rep);
355     }
356 
357 
358 
359     /**
360      * Returns all repetitions of Relative Time and Units (TQ1-5).
361      */
362     public CQ[] getRelativeTimeAndUnits() {
363     	CQ[] retVal = this.getTypedField(5, new CQ[0]);
364     	return retVal;
365     }
366 
367 
368     /**
369      * Returns all repetitions of Relative Time and Units (TQ1-5).
370      */
371     public CQ[] getTq15_RelativeTimeAndUnits() {
372     	CQ[] retVal = this.getTypedField(5, new CQ[0]);
373     	return retVal;
374     }
375 
376 
377     /**
378      * Returns a count of the current number of repetitions of Relative Time and Units (TQ1-5).
379      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
380      * it will return zero.
381      */
382     public int getRelativeTimeAndUnitsReps() {
383     	return this.getReps(5);
384     }
385 
386 
387     /**
388      * Returns a specific repetition of
389      * TQ1-5: "Relative Time and Units" - creates it if necessary
390      *
391      * @param rep The repetition index (0-indexed)
392      */
393     public CQ getRelativeTimeAndUnits(int rep) { 
394 		CQ retVal = this.getTypedField(5, rep);
395 		return retVal;
396     }
397 
398     /**
399      * Returns a specific repetition of
400      * TQ1-5: "Relative Time and Units" - creates it if necessary
401      *
402      * @param rep The repetition index (0-indexed)
403      */
404     public CQ getTq15_RelativeTimeAndUnits(int rep) { 
405 		CQ retVal = this.getTypedField(5, rep);
406 		return retVal;
407     }
408 
409     /**
410      * Returns a count of the current number of repetitions of Relative Time and Units (TQ1-5).
411      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
412      * it will return zero.
413      */
414     public int getTq15_RelativeTimeAndUnitsReps() {
415     	return this.getReps(5);
416     }
417 
418 
419     /**
420      * Inserts a repetition of
421      * TQ1-5: "Relative Time and Units" at a specific index
422      *
423      * @param rep The repetition index (0-indexed)
424      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
425      */
426     public CQ insertRelativeTimeAndUnits(int rep) throws HL7Exception { 
427         return (CQ) super.insertRepetition(5, rep);
428     }
429 
430 
431     /**
432      * Inserts a repetition of
433      * TQ1-5: "Relative Time and Units" at a specific index
434      *
435      * @param rep The repetition index (0-indexed)
436      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
437      */
438     public CQ insertTq15_RelativeTimeAndUnits(int rep) throws HL7Exception { 
439         return (CQ) super.insertRepetition(5, rep);
440     }
441 
442 
443     /**
444      * Removes a repetition of
445      * TQ1-5: "Relative Time and Units" at a specific index
446      *
447      * @param rep The repetition index (0-indexed)
448      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
449      */
450     public CQ removeRelativeTimeAndUnits(int rep) throws HL7Exception { 
451         return (CQ) super.removeRepetition(5, rep);
452     }
453 
454 
455     /**
456      * Removes a repetition of
457      * TQ1-5: "Relative Time and Units" at a specific index
458      *
459      * @param rep The repetition index (0-indexed)
460      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
461      */
462     public CQ removeTq15_RelativeTimeAndUnits(int rep) throws HL7Exception { 
463         return (CQ) super.removeRepetition(5, rep);
464     }
465 
466 
467 
468 
469     /**
470      * Returns
471      * TQ1-6: "Service Duration" - creates it if necessary
472      */
473     public CQ getServiceDuration() { 
474 		CQ retVal = this.getTypedField(6, 0);
475 		return retVal;
476     }
477     
478     /**
479      * Returns
480      * TQ1-6: "Service Duration" - creates it if necessary
481      */
482     public CQ getTq16_ServiceDuration() { 
483 		CQ retVal = this.getTypedField(6, 0);
484 		return retVal;
485     }
486 
487 
488 
489     /**
490      * Returns
491      * TQ1-7: "Start date/time" - creates it if necessary
492      */
493     public TS getStartDateTime() { 
494 		TS retVal = this.getTypedField(7, 0);
495 		return retVal;
496     }
497     
498     /**
499      * Returns
500      * TQ1-7: "Start date/time" - creates it if necessary
501      */
502     public TS getTq17_StartDateTime() { 
503 		TS retVal = this.getTypedField(7, 0);
504 		return retVal;
505     }
506 
507 
508 
509     /**
510      * Returns
511      * TQ1-8: "End date/time" - creates it if necessary
512      */
513     public TS getEndDateTime() { 
514 		TS retVal = this.getTypedField(8, 0);
515 		return retVal;
516     }
517     
518     /**
519      * Returns
520      * TQ1-8: "End date/time" - creates it if necessary
521      */
522     public TS getTq18_EndDateTime() { 
523 		TS retVal = this.getTypedField(8, 0);
524 		return retVal;
525     }
526 
527 
528     /**
529      * Returns all repetitions of Priority (TQ1-9).
530      */
531     public CWE[] getPriority() {
532     	CWE[] retVal = this.getTypedField(9, new CWE[0]);
533     	return retVal;
534     }
535 
536 
537     /**
538      * Returns all repetitions of Priority (TQ1-9).
539      */
540     public CWE[] getTq19_Priority() {
541     	CWE[] retVal = this.getTypedField(9, new CWE[0]);
542     	return retVal;
543     }
544 
545 
546     /**
547      * Returns a count of the current number of repetitions of Priority (TQ1-9).
548      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
549      * it will return zero.
550      */
551     public int getPriorityReps() {
552     	return this.getReps(9);
553     }
554 
555 
556     /**
557      * Returns a specific repetition of
558      * TQ1-9: "Priority" - creates it if necessary
559      *
560      * @param rep The repetition index (0-indexed)
561      */
562     public CWE getPriority(int rep) { 
563 		CWE retVal = this.getTypedField(9, rep);
564 		return retVal;
565     }
566 
567     /**
568      * Returns a specific repetition of
569      * TQ1-9: "Priority" - creates it if necessary
570      *
571      * @param rep The repetition index (0-indexed)
572      */
573     public CWE getTq19_Priority(int rep) { 
574 		CWE retVal = this.getTypedField(9, rep);
575 		return retVal;
576     }
577 
578     /**
579      * Returns a count of the current number of repetitions of Priority (TQ1-9).
580      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
581      * it will return zero.
582      */
583     public int getTq19_PriorityReps() {
584     	return this.getReps(9);
585     }
586 
587 
588     /**
589      * Inserts a repetition of
590      * TQ1-9: "Priority" at a specific index
591      *
592      * @param rep The repetition index (0-indexed)
593      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
594      */
595     public CWE insertPriority(int rep) throws HL7Exception { 
596         return (CWE) super.insertRepetition(9, rep);
597     }
598 
599 
600     /**
601      * Inserts a repetition of
602      * TQ1-9: "Priority" at a specific index
603      *
604      * @param rep The repetition index (0-indexed)
605      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
606      */
607     public CWE insertTq19_Priority(int rep) throws HL7Exception { 
608         return (CWE) super.insertRepetition(9, rep);
609     }
610 
611 
612     /**
613      * Removes a repetition of
614      * TQ1-9: "Priority" at a specific index
615      *
616      * @param rep The repetition index (0-indexed)
617      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
618      */
619     public CWE removePriority(int rep) throws HL7Exception { 
620         return (CWE) super.removeRepetition(9, rep);
621     }
622 
623 
624     /**
625      * Removes a repetition of
626      * TQ1-9: "Priority" at a specific index
627      *
628      * @param rep The repetition index (0-indexed)
629      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
630      */
631     public CWE removeTq19_Priority(int rep) throws HL7Exception { 
632         return (CWE) super.removeRepetition(9, rep);
633     }
634 
635 
636 
637 
638     /**
639      * Returns
640      * TQ1-10: "Condition text" - creates it if necessary
641      */
642     public TX getConditionText() { 
643 		TX retVal = this.getTypedField(10, 0);
644 		return retVal;
645     }
646     
647     /**
648      * Returns
649      * TQ1-10: "Condition text" - creates it if necessary
650      */
651     public TX getTq110_ConditionText() { 
652 		TX retVal = this.getTypedField(10, 0);
653 		return retVal;
654     }
655 
656 
657 
658     /**
659      * Returns
660      * TQ1-11: "Text instruction" - creates it if necessary
661      */
662     public TX getTextInstruction() { 
663 		TX retVal = this.getTypedField(11, 0);
664 		return retVal;
665     }
666     
667     /**
668      * Returns
669      * TQ1-11: "Text instruction" - creates it if necessary
670      */
671     public TX getTq111_TextInstruction() { 
672 		TX retVal = this.getTypedField(11, 0);
673 		return retVal;
674     }
675 
676 
677 
678     /**
679      * Returns
680      * TQ1-12: "Conjunction" - creates it if necessary
681      */
682     public ID getConjunction() { 
683 		ID retVal = this.getTypedField(12, 0);
684 		return retVal;
685     }
686     
687     /**
688      * Returns
689      * TQ1-12: "Conjunction" - creates it if necessary
690      */
691     public ID getTq112_Conjunction() { 
692 		ID retVal = this.getTypedField(12, 0);
693 		return retVal;
694     }
695 
696 
697 
698     /**
699      * Returns
700      * TQ1-13: "Occurrence duration" - creates it if necessary
701      */
702     public CQ getOccurrenceDuration() { 
703 		CQ retVal = this.getTypedField(13, 0);
704 		return retVal;
705     }
706     
707     /**
708      * Returns
709      * TQ1-13: "Occurrence duration" - creates it if necessary
710      */
711     public CQ getTq113_OccurrenceDuration() { 
712 		CQ retVal = this.getTypedField(13, 0);
713 		return retVal;
714     }
715 
716 
717 
718     /**
719      * Returns
720      * TQ1-14: "Total occurrence's" - creates it if necessary
721      */
722     public NM getTotalOccurrenceS() { 
723 		NM retVal = this.getTypedField(14, 0);
724 		return retVal;
725     }
726     
727     /**
728      * Returns
729      * TQ1-14: "Total occurrence's" - creates it if necessary
730      */
731     public NM getTq114_TotalOccurrenceS() { 
732 		NM retVal = this.getTypedField(14, 0);
733 		return retVal;
734     }
735 
736 
737 
738 
739 
740     /** {@inheritDoc} */   
741     protected Type createNewTypeWithoutReflection(int field) {
742        switch (field) {
743           case 0: return new SI(getMessage());
744           case 1: return new CQ(getMessage());
745           case 2: return new RPT(getMessage());
746           case 3: return new TM(getMessage());
747           case 4: return new CQ(getMessage());
748           case 5: return new CQ(getMessage());
749           case 6: return new TS(getMessage());
750           case 7: return new TS(getMessage());
751           case 8: return new CWE(getMessage());
752           case 9: return new TX(getMessage());
753           case 10: return new TX(getMessage());
754           case 11: return new ID(getMessage(), new Integer( 427 ));
755           case 12: return new CQ(getMessage());
756           case 13: return new NM(getMessage());
757           default: return null;
758        }
759    }
760 
761 
762 }
763