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 OM2 message segment (Numeric Observation). 
50   * This segment has the following fields:</p>
51   * <ul>
52       * <li>OM2-1: Sequence Number - Test/Observation Master File (NM) <b>optional </b>
53       * <li>OM2-2: Units of Measure (CE) <b>optional </b>
54       * <li>OM2-3: Range of Decimal Precision (NM) <b>optional repeating</b>
55       * <li>OM2-4: Corresponding SI Units of Measure (CE) <b>optional </b>
56       * <li>OM2-5: SI Conversion Factor (TX) <b>optional </b>
57       * <li>OM2-6: Reference (Normal) Range - Ordinal and Continuous Observations (RFR) <b>optional repeating</b>
58       * <li>OM2-7: Critical Range for Ordinal and Continuous Observations (RFR) <b>optional repeating</b>
59       * <li>OM2-8: Absolute Range for Ordinal and Continuous Observations (RFR) <b>optional </b>
60       * <li>OM2-9: Delta Check Criteria (DLT) <b>optional repeating</b>
61       * <li>OM2-10: Minimum Meaningful Increments (NM) <b>optional </b>
62   * </ul>
63   */
64  @SuppressWarnings("unused")
65  public class OM2 extends AbstractSegment {
66  
67      /** 
68       * Creates a new OM2 segment
69       */
70      public OM2(Group parent, ModelClassFactory factory) {
71         super(parent, factory);
72         init(factory);
73      }
74  
75      private void init(ModelClassFactory factory) {
76         try {
77                                    this.add(NM.class, false, 1, 4, new Object[]{ getMessage() }, "Sequence Number - Test/Observation Master File");
78                                    this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Units of Measure");
79                                    this.add(NM.class, false, 0, 10, new Object[]{ getMessage() }, "Range of Decimal Precision");
80                                    this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Corresponding SI Units of Measure");
81                                    this.add(TX.class, false, 1, 60, new Object[]{ getMessage() }, "SI Conversion Factor");
82                                    this.add(RFR.class, false, 0, 250, new Object[]{ getMessage() }, "Reference (Normal) Range - Ordinal and Continuous Observations");
83                                    this.add(RFR.class, false, 0, 205, new Object[]{ getMessage() }, "Critical Range for Ordinal and Continuous Observations");
84                                    this.add(RFR.class, false, 1, 250, new Object[]{ getMessage() }, "Absolute Range for Ordinal and Continuous Observations");
85                                    this.add(DLT.class, false, 0, 250, new Object[]{ getMessage() }, "Delta Check Criteria");
86                                    this.add(NM.class, false, 1, 20, new Object[]{ getMessage() }, "Minimum Meaningful Increments");
87         } catch(HL7Exception e) {
88            log.error("Unexpected error creating OM2 - this is probably a bug in the source code generator.", e);
89         }
90      }
91  
92  
93  
94      /**
95       * Returns
96       * OM2-1: "Sequence Number - Test/Observation Master File" - creates it if necessary
97       */
98      public NM getSequenceNumberTestObservationMasterFile() { 
99  		NM retVal = this.getTypedField(1, 0);
100 		return retVal;
101     }
102     
103     /**
104      * Returns
105      * OM2-1: "Sequence Number - Test/Observation Master File" - creates it if necessary
106      */
107     public NM getOm21_SequenceNumberTestObservationMasterFile() { 
108 		NM retVal = this.getTypedField(1, 0);
109 		return retVal;
110     }
111 
112 
113 
114     /**
115      * Returns
116      * OM2-2: "Units of Measure" - creates it if necessary
117      */
118     public CE getUnitsOfMeasure() { 
119 		CE retVal = this.getTypedField(2, 0);
120 		return retVal;
121     }
122     
123     /**
124      * Returns
125      * OM2-2: "Units of Measure" - creates it if necessary
126      */
127     public CE getOm22_UnitsOfMeasure() { 
128 		CE retVal = this.getTypedField(2, 0);
129 		return retVal;
130     }
131 
132 
133     /**
134      * Returns all repetitions of Range of Decimal Precision (OM2-3).
135      */
136     public NM[] getRangeOfDecimalPrecision() {
137     	NM[] retVal = this.getTypedField(3, new NM[0]);
138     	return retVal;
139     }
140 
141 
142     /**
143      * Returns all repetitions of Range of Decimal Precision (OM2-3).
144      */
145     public NM[] getOm23_RangeOfDecimalPrecision() {
146     	NM[] retVal = this.getTypedField(3, new NM[0]);
147     	return retVal;
148     }
149 
150 
151     /**
152      * Returns a count of the current number of repetitions of Range of Decimal Precision (OM2-3).
153      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
154      * it will return zero.
155      */
156     public int getRangeOfDecimalPrecisionReps() {
157     	return this.getReps(3);
158     }
159 
160 
161     /**
162      * Returns a specific repetition of
163      * OM2-3: "Range of Decimal Precision" - creates it if necessary
164      *
165      * @param rep The repetition index (0-indexed)
166      */
167     public NM getRangeOfDecimalPrecision(int rep) { 
168 		NM retVal = this.getTypedField(3, rep);
169 		return retVal;
170     }
171 
172     /**
173      * Returns a specific repetition of
174      * OM2-3: "Range of Decimal Precision" - creates it if necessary
175      *
176      * @param rep The repetition index (0-indexed)
177      */
178     public NM getOm23_RangeOfDecimalPrecision(int rep) { 
179 		NM retVal = this.getTypedField(3, rep);
180 		return retVal;
181     }
182 
183     /**
184      * Returns a count of the current number of repetitions of Range of Decimal Precision (OM2-3).
185      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
186      * it will return zero.
187      */
188     public int getOm23_RangeOfDecimalPrecisionReps() {
189     	return this.getReps(3);
190     }
191 
192 
193     /**
194      * Inserts a repetition of
195      * OM2-3: "Range of Decimal Precision" at a specific index
196      *
197      * @param rep The repetition index (0-indexed)
198      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
199      */
200     public NM insertRangeOfDecimalPrecision(int rep) throws HL7Exception { 
201         return (NM) super.insertRepetition(3, rep);
202     }
203 
204 
205     /**
206      * Inserts a repetition of
207      * OM2-3: "Range of Decimal Precision" at a specific index
208      *
209      * @param rep The repetition index (0-indexed)
210      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
211      */
212     public NM insertOm23_RangeOfDecimalPrecision(int rep) throws HL7Exception { 
213         return (NM) super.insertRepetition(3, rep);
214     }
215 
216 
217     /**
218      * Removes a repetition of
219      * OM2-3: "Range of Decimal Precision" at a specific index
220      *
221      * @param rep The repetition index (0-indexed)
222      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
223      */
224     public NM removeRangeOfDecimalPrecision(int rep) throws HL7Exception { 
225         return (NM) super.removeRepetition(3, rep);
226     }
227 
228 
229     /**
230      * Removes a repetition of
231      * OM2-3: "Range of Decimal Precision" at a specific index
232      *
233      * @param rep The repetition index (0-indexed)
234      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
235      */
236     public NM removeOm23_RangeOfDecimalPrecision(int rep) throws HL7Exception { 
237         return (NM) super.removeRepetition(3, rep);
238     }
239 
240 
241 
242 
243     /**
244      * Returns
245      * OM2-4: "Corresponding SI Units of Measure" - creates it if necessary
246      */
247     public CE getCorrespondingSIUnitsOfMeasure() { 
248 		CE retVal = this.getTypedField(4, 0);
249 		return retVal;
250     }
251     
252     /**
253      * Returns
254      * OM2-4: "Corresponding SI Units of Measure" - creates it if necessary
255      */
256     public CE getOm24_CorrespondingSIUnitsOfMeasure() { 
257 		CE retVal = this.getTypedField(4, 0);
258 		return retVal;
259     }
260 
261 
262 
263     /**
264      * Returns
265      * OM2-5: "SI Conversion Factor" - creates it if necessary
266      */
267     public TX getSIConversionFactor() { 
268 		TX retVal = this.getTypedField(5, 0);
269 		return retVal;
270     }
271     
272     /**
273      * Returns
274      * OM2-5: "SI Conversion Factor" - creates it if necessary
275      */
276     public TX getOm25_SIConversionFactor() { 
277 		TX retVal = this.getTypedField(5, 0);
278 		return retVal;
279     }
280 
281 
282     /**
283      * Returns all repetitions of Reference (Normal) Range - Ordinal and Continuous Observations (OM2-6).
284      */
285     public RFR[] getReferenceNormalRangeOrdinalAndContinuousObservations() {
286     	RFR[] retVal = this.getTypedField(6, new RFR[0]);
287     	return retVal;
288     }
289 
290 
291     /**
292      * Returns all repetitions of Reference (Normal) Range - Ordinal and Continuous Observations (OM2-6).
293      */
294     public RFR[] getOm26_ReferenceNormalRangeOrdinalAndContinuousObservations() {
295     	RFR[] retVal = this.getTypedField(6, new RFR[0]);
296     	return retVal;
297     }
298 
299 
300     /**
301      * Returns a count of the current number of repetitions of Reference (Normal) Range - Ordinal and Continuous Observations (OM2-6).
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 getReferenceNormalRangeOrdinalAndContinuousObservationsReps() {
306     	return this.getReps(6);
307     }
308 
309 
310     /**
311      * Returns a specific repetition of
312      * OM2-6: "Reference (Normal) Range - Ordinal and Continuous Observations" - creates it if necessary
313      *
314      * @param rep The repetition index (0-indexed)
315      */
316     public RFR getReferenceNormalRangeOrdinalAndContinuousObservations(int rep) { 
317 		RFR retVal = this.getTypedField(6, rep);
318 		return retVal;
319     }
320 
321     /**
322      * Returns a specific repetition of
323      * OM2-6: "Reference (Normal) Range - Ordinal and Continuous Observations" - creates it if necessary
324      *
325      * @param rep The repetition index (0-indexed)
326      */
327     public RFR getOm26_ReferenceNormalRangeOrdinalAndContinuousObservations(int rep) { 
328 		RFR retVal = this.getTypedField(6, rep);
329 		return retVal;
330     }
331 
332     /**
333      * Returns a count of the current number of repetitions of Reference (Normal) Range - Ordinal and Continuous Observations (OM2-6).
334      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
335      * it will return zero.
336      */
337     public int getOm26_ReferenceNormalRangeOrdinalAndContinuousObservationsReps() {
338     	return this.getReps(6);
339     }
340 
341 
342     /**
343      * Inserts a repetition of
344      * OM2-6: "Reference (Normal) Range - Ordinal and Continuous Observations" at a specific index
345      *
346      * @param rep The repetition index (0-indexed)
347      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
348      */
349     public RFR insertReferenceNormalRangeOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
350         return (RFR) super.insertRepetition(6, rep);
351     }
352 
353 
354     /**
355      * Inserts a repetition of
356      * OM2-6: "Reference (Normal) Range - Ordinal and Continuous Observations" at a specific index
357      *
358      * @param rep The repetition index (0-indexed)
359      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
360      */
361     public RFR insertOm26_ReferenceNormalRangeOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
362         return (RFR) super.insertRepetition(6, rep);
363     }
364 
365 
366     /**
367      * Removes a repetition of
368      * OM2-6: "Reference (Normal) Range - Ordinal and Continuous Observations" at a specific index
369      *
370      * @param rep The repetition index (0-indexed)
371      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
372      */
373     public RFR removeReferenceNormalRangeOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
374         return (RFR) super.removeRepetition(6, rep);
375     }
376 
377 
378     /**
379      * Removes a repetition of
380      * OM2-6: "Reference (Normal) Range - Ordinal and Continuous Observations" at a specific index
381      *
382      * @param rep The repetition index (0-indexed)
383      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
384      */
385     public RFR removeOm26_ReferenceNormalRangeOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
386         return (RFR) super.removeRepetition(6, rep);
387     }
388 
389 
390 
391     /**
392      * Returns all repetitions of Critical Range for Ordinal and Continuous Observations (OM2-7).
393      */
394     public RFR[] getCriticalRangeForOrdinalAndContinuousObservations() {
395     	RFR[] retVal = this.getTypedField(7, new RFR[0]);
396     	return retVal;
397     }
398 
399 
400     /**
401      * Returns all repetitions of Critical Range for Ordinal and Continuous Observations (OM2-7).
402      */
403     public RFR[] getOm27_CriticalRangeForOrdinalAndContinuousObservations() {
404     	RFR[] retVal = this.getTypedField(7, new RFR[0]);
405     	return retVal;
406     }
407 
408 
409     /**
410      * Returns a count of the current number of repetitions of Critical Range for Ordinal and Continuous Observations (OM2-7).
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 getCriticalRangeForOrdinalAndContinuousObservationsReps() {
415     	return this.getReps(7);
416     }
417 
418 
419     /**
420      * Returns a specific repetition of
421      * OM2-7: "Critical Range for Ordinal and Continuous Observations" - creates it if necessary
422      *
423      * @param rep The repetition index (0-indexed)
424      */
425     public RFR getCriticalRangeForOrdinalAndContinuousObservations(int rep) { 
426 		RFR retVal = this.getTypedField(7, rep);
427 		return retVal;
428     }
429 
430     /**
431      * Returns a specific repetition of
432      * OM2-7: "Critical Range for Ordinal and Continuous Observations" - creates it if necessary
433      *
434      * @param rep The repetition index (0-indexed)
435      */
436     public RFR getOm27_CriticalRangeForOrdinalAndContinuousObservations(int rep) { 
437 		RFR retVal = this.getTypedField(7, rep);
438 		return retVal;
439     }
440 
441     /**
442      * Returns a count of the current number of repetitions of Critical Range for Ordinal and Continuous Observations (OM2-7).
443      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
444      * it will return zero.
445      */
446     public int getOm27_CriticalRangeForOrdinalAndContinuousObservationsReps() {
447     	return this.getReps(7);
448     }
449 
450 
451     /**
452      * Inserts a repetition of
453      * OM2-7: "Critical Range for Ordinal and Continuous Observations" at a specific index
454      *
455      * @param rep The repetition index (0-indexed)
456      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
457      */
458     public RFR insertCriticalRangeForOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
459         return (RFR) super.insertRepetition(7, rep);
460     }
461 
462 
463     /**
464      * Inserts a repetition of
465      * OM2-7: "Critical Range for Ordinal and Continuous Observations" at a specific index
466      *
467      * @param rep The repetition index (0-indexed)
468      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
469      */
470     public RFR insertOm27_CriticalRangeForOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
471         return (RFR) super.insertRepetition(7, rep);
472     }
473 
474 
475     /**
476      * Removes a repetition of
477      * OM2-7: "Critical Range for Ordinal and Continuous Observations" at a specific index
478      *
479      * @param rep The repetition index (0-indexed)
480      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
481      */
482     public RFR removeCriticalRangeForOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
483         return (RFR) super.removeRepetition(7, rep);
484     }
485 
486 
487     /**
488      * Removes a repetition of
489      * OM2-7: "Critical Range for Ordinal and Continuous Observations" at a specific index
490      *
491      * @param rep The repetition index (0-indexed)
492      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
493      */
494     public RFR removeOm27_CriticalRangeForOrdinalAndContinuousObservations(int rep) throws HL7Exception { 
495         return (RFR) super.removeRepetition(7, rep);
496     }
497 
498 
499 
500 
501     /**
502      * Returns
503      * OM2-8: "Absolute Range for Ordinal and Continuous Observations" - creates it if necessary
504      */
505     public RFR getAbsoluteRangeForOrdinalAndContinuousObservations() { 
506 		RFR retVal = this.getTypedField(8, 0);
507 		return retVal;
508     }
509     
510     /**
511      * Returns
512      * OM2-8: "Absolute Range for Ordinal and Continuous Observations" - creates it if necessary
513      */
514     public RFR getOm28_AbsoluteRangeForOrdinalAndContinuousObservations() { 
515 		RFR retVal = this.getTypedField(8, 0);
516 		return retVal;
517     }
518 
519 
520     /**
521      * Returns all repetitions of Delta Check Criteria (OM2-9).
522      */
523     public DLT[] getDeltaCheckCriteria() {
524     	DLT[] retVal = this.getTypedField(9, new DLT[0]);
525     	return retVal;
526     }
527 
528 
529     /**
530      * Returns all repetitions of Delta Check Criteria (OM2-9).
531      */
532     public DLT[] getOm29_DeltaCheckCriteria() {
533     	DLT[] retVal = this.getTypedField(9, new DLT[0]);
534     	return retVal;
535     }
536 
537 
538     /**
539      * Returns a count of the current number of repetitions of Delta Check Criteria (OM2-9).
540      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
541      * it will return zero.
542      */
543     public int getDeltaCheckCriteriaReps() {
544     	return this.getReps(9);
545     }
546 
547 
548     /**
549      * Returns a specific repetition of
550      * OM2-9: "Delta Check Criteria" - creates it if necessary
551      *
552      * @param rep The repetition index (0-indexed)
553      */
554     public DLT getDeltaCheckCriteria(int rep) { 
555 		DLT retVal = this.getTypedField(9, rep);
556 		return retVal;
557     }
558 
559     /**
560      * Returns a specific repetition of
561      * OM2-9: "Delta Check Criteria" - creates it if necessary
562      *
563      * @param rep The repetition index (0-indexed)
564      */
565     public DLT getOm29_DeltaCheckCriteria(int rep) { 
566 		DLT retVal = this.getTypedField(9, rep);
567 		return retVal;
568     }
569 
570     /**
571      * Returns a count of the current number of repetitions of Delta Check Criteria (OM2-9).
572      * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
573      * it will return zero.
574      */
575     public int getOm29_DeltaCheckCriteriaReps() {
576     	return this.getReps(9);
577     }
578 
579 
580     /**
581      * Inserts a repetition of
582      * OM2-9: "Delta Check Criteria" at a specific index
583      *
584      * @param rep The repetition index (0-indexed)
585      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
586      */
587     public DLT insertDeltaCheckCriteria(int rep) throws HL7Exception { 
588         return (DLT) super.insertRepetition(9, rep);
589     }
590 
591 
592     /**
593      * Inserts a repetition of
594      * OM2-9: "Delta Check Criteria" at a specific index
595      *
596      * @param rep The repetition index (0-indexed)
597      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
598      */
599     public DLT insertOm29_DeltaCheckCriteria(int rep) throws HL7Exception { 
600         return (DLT) super.insertRepetition(9, rep);
601     }
602 
603 
604     /**
605      * Removes a repetition of
606      * OM2-9: "Delta Check Criteria" at a specific index
607      *
608      * @param rep The repetition index (0-indexed)
609      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
610      */
611     public DLT removeDeltaCheckCriteria(int rep) throws HL7Exception { 
612         return (DLT) super.removeRepetition(9, rep);
613     }
614 
615 
616     /**
617      * Removes a repetition of
618      * OM2-9: "Delta Check Criteria" at a specific index
619      *
620      * @param rep The repetition index (0-indexed)
621      * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
622      */
623     public DLT removeOm29_DeltaCheckCriteria(int rep) throws HL7Exception { 
624         return (DLT) super.removeRepetition(9, rep);
625     }
626 
627 
628 
629 
630     /**
631      * Returns
632      * OM2-10: "Minimum Meaningful Increments" - creates it if necessary
633      */
634     public NM getMinimumMeaningfulIncrements() { 
635 		NM retVal = this.getTypedField(10, 0);
636 		return retVal;
637     }
638     
639     /**
640      * Returns
641      * OM2-10: "Minimum Meaningful Increments" - creates it if necessary
642      */
643     public NM getOm210_MinimumMeaningfulIncrements() { 
644 		NM retVal = this.getTypedField(10, 0);
645 		return retVal;
646     }
647 
648 
649 
650 
651 
652     /** {@inheritDoc} */   
653     protected Type createNewTypeWithoutReflection(int field) {
654        switch (field) {
655           case 0: return new NM(getMessage());
656           case 1: return new CE(getMessage());
657           case 2: return new NM(getMessage());
658           case 3: return new CE(getMessage());
659           case 4: return new TX(getMessage());
660           case 5: return new RFR(getMessage());
661           case 6: return new RFR(getMessage());
662           case 7: return new RFR(getMessage());
663           case 8: return new DLT(getMessage());
664           case 9: return new NM(getMessage());
665           default: return null;
666        }
667    }
668 
669 
670 }
671