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.v25.segment;
035
036// import ca.uhn.hl7v2.model.v25.group.*;
037import ca.uhn.hl7v2.model.v25.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 OBX message segment (Observation/Result). 
050 * This segment has the following fields:</p>
051 * <ul>
052     * <li>OBX-1: Set ID - OBX (SI) <b>optional </b>
053     * <li>OBX-2: Value Type (ID) <b>optional </b>
054     * <li>OBX-3: Observation Identifier (CE) <b> </b>
055     * <li>OBX-4: Observation Sub-ID (ST) <b>optional </b>
056     * <li>OBX-5: Observation Value (Varies) <b>optional repeating</b>
057     * <li>OBX-6: Units (CE) <b>optional </b>
058     * <li>OBX-7: References Range (ST) <b>optional </b>
059     * <li>OBX-8: Abnormal Flags (IS) <b>optional repeating</b>
060     * <li>OBX-9: Probability (NM) <b>optional </b>
061     * <li>OBX-10: Nature of Abnormal Test (ID) <b>optional repeating</b>
062     * <li>OBX-11: Observation Result Status (ID) <b> </b>
063     * <li>OBX-12: Effective Date of Reference Range (TS) <b>optional </b>
064     * <li>OBX-13: User Defined Access Checks (ST) <b>optional </b>
065     * <li>OBX-14: Date/Time of the Observation (TS) <b>optional </b>
066     * <li>OBX-15: Producer's ID (CE) <b>optional </b>
067     * <li>OBX-16: Responsible Observer (XCN) <b>optional repeating</b>
068     * <li>OBX-17: Observation Method (CE) <b>optional repeating</b>
069     * <li>OBX-18: Equipment Instance Identifier (EI) <b>optional repeating</b>
070     * <li>OBX-19: Date/Time of the Analysis (TS) <b>optional </b>
071 * </ul>
072 */
073@SuppressWarnings("unused")
074public class OBX extends AbstractSegment {
075
076    /** 
077     * Creates a new OBX segment
078     */
079    public OBX(Group parent, ModelClassFactory factory) {
080       super(parent, factory);
081       init(factory);
082    }
083
084    private void init(ModelClassFactory factory) {
085       try {
086                                  this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - OBX");
087                                              this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(125) }, "Value Type");
088                                  this.add(CE.class, true, 1, 250, new Object[]{ getMessage() }, "Observation Identifier");
089                                  this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Observation Sub-ID");
090                                  this.add(Varies.class, false, 0, 99999, new Object[]{ getMessage() }, "Observation Value");
091                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Units");
092                                  this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "References Range");
093                                              this.add(IS.class, false, 0, 5, new Object[]{ getMessage(), new Integer(78) }, "Abnormal Flags");
094                                  this.add(NM.class, false, 1, 5, new Object[]{ getMessage() }, "Probability");
095                                              this.add(ID.class, false, 0, 2, new Object[]{ getMessage(), new Integer(80) }, "Nature of Abnormal Test");
096                                              this.add(ID.class, true, 1, 1, new Object[]{ getMessage(), new Integer(85) }, "Observation Result Status");
097                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective Date of Reference Range");
098                                  this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "User Defined Access Checks");
099                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of the Observation");
100                                  this.add(CE.class, false, 1, 250, new Object[]{ getMessage() }, "Producer's ID");
101                                  this.add(XCN.class, false, 0, 250, new Object[]{ getMessage() }, "Responsible Observer");
102                                  this.add(CE.class, false, 0, 250, new Object[]{ getMessage() }, "Observation Method");
103                                  this.add(EI.class, false, 0, 22, new Object[]{ getMessage() }, "Equipment Instance Identifier");
104                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of the Analysis");
105       } catch(HL7Exception e) {
106          log.error("Unexpected error creating OBX - this is probably a bug in the source code generator.", e);
107       }
108    }
109
110
111
112    /**
113     * Returns
114     * OBX-1: "Set ID - OBX" - creates it if necessary
115     */
116    public SI getSetIDOBX() { 
117                SI retVal = this.getTypedField(1, 0);
118                return retVal;
119    }
120    
121    /**
122     * Returns
123     * OBX-1: "Set ID - OBX" - creates it if necessary
124     */
125    public SI getObx1_SetIDOBX() { 
126                SI retVal = this.getTypedField(1, 0);
127                return retVal;
128    }
129
130
131
132    /**
133     * Returns
134     * OBX-2: "Value Type" - creates it if necessary
135     */
136    public ID getValueType() { 
137                ID retVal = this.getTypedField(2, 0);
138                return retVal;
139    }
140    
141    /**
142     * Returns
143     * OBX-2: "Value Type" - creates it if necessary
144     */
145    public ID getObx2_ValueType() { 
146                ID retVal = this.getTypedField(2, 0);
147                return retVal;
148    }
149
150
151
152    /**
153     * Returns
154     * OBX-3: "Observation Identifier" - creates it if necessary
155     */
156    public CE getObservationIdentifier() { 
157                CE retVal = this.getTypedField(3, 0);
158                return retVal;
159    }
160    
161    /**
162     * Returns
163     * OBX-3: "Observation Identifier" - creates it if necessary
164     */
165    public CE getObx3_ObservationIdentifier() { 
166                CE retVal = this.getTypedField(3, 0);
167                return retVal;
168    }
169
170
171
172    /**
173     * Returns
174     * OBX-4: "Observation Sub-ID" - creates it if necessary
175     */
176    public ST getObservationSubID() { 
177                ST retVal = this.getTypedField(4, 0);
178                return retVal;
179    }
180    
181    /**
182     * Returns
183     * OBX-4: "Observation Sub-ID" - creates it if necessary
184     */
185    public ST getObx4_ObservationSubID() { 
186                ST retVal = this.getTypedField(4, 0);
187                return retVal;
188    }
189
190
191    /**
192     * Returns all repetitions of Observation Value (OBX-5).
193     */
194    public Varies[] getObservationValue() {
195        Varies[] retVal = this.getTypedField(5, new Varies[0]);
196        return retVal;
197    }
198
199
200    /**
201     * Returns all repetitions of Observation Value (OBX-5).
202     */
203    public Varies[] getObx5_ObservationValue() {
204        Varies[] retVal = this.getTypedField(5, new Varies[0]);
205        return retVal;
206    }
207
208
209    /**
210     * Returns a count of the current number of repetitions of Observation Value (OBX-5).
211     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
212     * it will return zero.
213     */
214    public int getObservationValueReps() {
215        return this.getReps(5);
216    }
217
218
219    /**
220     * Returns a specific repetition of
221     * OBX-5: "Observation Value" - creates it if necessary
222     *
223     * @param rep The repetition index (0-indexed)
224     */
225    public Varies getObservationValue(int rep) { 
226                Varies retVal = this.getTypedField(5, rep);
227                return retVal;
228    }
229
230    /**
231     * Returns a specific repetition of
232     * OBX-5: "Observation Value" - creates it if necessary
233     *
234     * @param rep The repetition index (0-indexed)
235     */
236    public Varies getObx5_ObservationValue(int rep) { 
237                Varies retVal = this.getTypedField(5, rep);
238                return retVal;
239    }
240
241    /**
242     * Returns a count of the current number of repetitions of Observation Value (OBX-5).
243     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
244     * it will return zero.
245     */
246    public int getObx5_ObservationValueReps() {
247        return this.getReps(5);
248    }
249
250
251    /**
252     * Inserts a repetition of
253     * OBX-5: "Observation Value" at a specific index
254     *
255     * @param rep The repetition index (0-indexed)
256     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
257     */
258    public Varies insertObservationValue(int rep) throws HL7Exception { 
259        return (Varies) super.insertRepetition(5, rep);
260    }
261
262
263    /**
264     * Inserts a repetition of
265     * OBX-5: "Observation Value" at a specific index
266     *
267     * @param rep The repetition index (0-indexed)
268     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
269     */
270    public Varies insertObx5_ObservationValue(int rep) throws HL7Exception { 
271        return (Varies) super.insertRepetition(5, rep);
272    }
273
274
275    /**
276     * Removes a repetition of
277     * OBX-5: "Observation Value" at a specific index
278     *
279     * @param rep The repetition index (0-indexed)
280     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
281     */
282    public Varies removeObservationValue(int rep) throws HL7Exception { 
283        return (Varies) super.removeRepetition(5, rep);
284    }
285
286
287    /**
288     * Removes a repetition of
289     * OBX-5: "Observation Value" at a specific index
290     *
291     * @param rep The repetition index (0-indexed)
292     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
293     */
294    public Varies removeObx5_ObservationValue(int rep) throws HL7Exception { 
295        return (Varies) super.removeRepetition(5, rep);
296    }
297
298
299
300
301    /**
302     * Returns
303     * OBX-6: "Units" - creates it if necessary
304     */
305    public CE getUnits() { 
306                CE retVal = this.getTypedField(6, 0);
307                return retVal;
308    }
309    
310    /**
311     * Returns
312     * OBX-6: "Units" - creates it if necessary
313     */
314    public CE getObx6_Units() { 
315                CE retVal = this.getTypedField(6, 0);
316                return retVal;
317    }
318
319
320
321    /**
322     * Returns
323     * OBX-7: "References Range" - creates it if necessary
324     */
325    public ST getReferencesRange() { 
326                ST retVal = this.getTypedField(7, 0);
327                return retVal;
328    }
329    
330    /**
331     * Returns
332     * OBX-7: "References Range" - creates it if necessary
333     */
334    public ST getObx7_ReferencesRange() { 
335                ST retVal = this.getTypedField(7, 0);
336                return retVal;
337    }
338
339
340    /**
341     * Returns all repetitions of Abnormal Flags (OBX-8).
342     */
343    public IS[] getAbnormalFlags() {
344        IS[] retVal = this.getTypedField(8, new IS[0]);
345        return retVal;
346    }
347
348
349    /**
350     * Returns all repetitions of Abnormal Flags (OBX-8).
351     */
352    public IS[] getObx8_AbnormalFlags() {
353        IS[] retVal = this.getTypedField(8, new IS[0]);
354        return retVal;
355    }
356
357
358    /**
359     * Returns a count of the current number of repetitions of Abnormal Flags (OBX-8).
360     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
361     * it will return zero.
362     */
363    public int getAbnormalFlagsReps() {
364        return this.getReps(8);
365    }
366
367
368    /**
369     * Returns a specific repetition of
370     * OBX-8: "Abnormal Flags" - creates it if necessary
371     *
372     * @param rep The repetition index (0-indexed)
373     */
374    public IS getAbnormalFlags(int rep) { 
375                IS retVal = this.getTypedField(8, rep);
376                return retVal;
377    }
378
379    /**
380     * Returns a specific repetition of
381     * OBX-8: "Abnormal Flags" - creates it if necessary
382     *
383     * @param rep The repetition index (0-indexed)
384     */
385    public IS getObx8_AbnormalFlags(int rep) { 
386                IS retVal = this.getTypedField(8, rep);
387                return retVal;
388    }
389
390    /**
391     * Returns a count of the current number of repetitions of Abnormal Flags (OBX-8).
392     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
393     * it will return zero.
394     */
395    public int getObx8_AbnormalFlagsReps() {
396        return this.getReps(8);
397    }
398
399
400    /**
401     * Inserts a repetition of
402     * OBX-8: "Abnormal Flags" at a specific index
403     *
404     * @param rep The repetition index (0-indexed)
405     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
406     */
407    public IS insertAbnormalFlags(int rep) throws HL7Exception { 
408        return (IS) super.insertRepetition(8, rep);
409    }
410
411
412    /**
413     * Inserts a repetition of
414     * OBX-8: "Abnormal Flags" at a specific index
415     *
416     * @param rep The repetition index (0-indexed)
417     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
418     */
419    public IS insertObx8_AbnormalFlags(int rep) throws HL7Exception { 
420        return (IS) super.insertRepetition(8, rep);
421    }
422
423
424    /**
425     * Removes a repetition of
426     * OBX-8: "Abnormal Flags" at a specific index
427     *
428     * @param rep The repetition index (0-indexed)
429     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
430     */
431    public IS removeAbnormalFlags(int rep) throws HL7Exception { 
432        return (IS) super.removeRepetition(8, rep);
433    }
434
435
436    /**
437     * Removes a repetition of
438     * OBX-8: "Abnormal Flags" at a specific index
439     *
440     * @param rep The repetition index (0-indexed)
441     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
442     */
443    public IS removeObx8_AbnormalFlags(int rep) throws HL7Exception { 
444        return (IS) super.removeRepetition(8, rep);
445    }
446
447
448
449
450    /**
451     * Returns
452     * OBX-9: "Probability" - creates it if necessary
453     */
454    public NM getProbability() { 
455                NM retVal = this.getTypedField(9, 0);
456                return retVal;
457    }
458    
459    /**
460     * Returns
461     * OBX-9: "Probability" - creates it if necessary
462     */
463    public NM getObx9_Probability() { 
464                NM retVal = this.getTypedField(9, 0);
465                return retVal;
466    }
467
468
469    /**
470     * Returns all repetitions of Nature of Abnormal Test (OBX-10).
471     */
472    public ID[] getNatureOfAbnormalTest() {
473        ID[] retVal = this.getTypedField(10, new ID[0]);
474        return retVal;
475    }
476
477
478    /**
479     * Returns all repetitions of Nature of Abnormal Test (OBX-10).
480     */
481    public ID[] getObx10_NatureOfAbnormalTest() {
482        ID[] retVal = this.getTypedField(10, new ID[0]);
483        return retVal;
484    }
485
486
487    /**
488     * Returns a count of the current number of repetitions of Nature of Abnormal Test (OBX-10).
489     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
490     * it will return zero.
491     */
492    public int getNatureOfAbnormalTestReps() {
493        return this.getReps(10);
494    }
495
496
497    /**
498     * Returns a specific repetition of
499     * OBX-10: "Nature of Abnormal Test" - creates it if necessary
500     *
501     * @param rep The repetition index (0-indexed)
502     */
503    public ID getNatureOfAbnormalTest(int rep) { 
504                ID retVal = this.getTypedField(10, rep);
505                return retVal;
506    }
507
508    /**
509     * Returns a specific repetition of
510     * OBX-10: "Nature of Abnormal Test" - creates it if necessary
511     *
512     * @param rep The repetition index (0-indexed)
513     */
514    public ID getObx10_NatureOfAbnormalTest(int rep) { 
515                ID retVal = this.getTypedField(10, rep);
516                return retVal;
517    }
518
519    /**
520     * Returns a count of the current number of repetitions of Nature of Abnormal Test (OBX-10).
521     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
522     * it will return zero.
523     */
524    public int getObx10_NatureOfAbnormalTestReps() {
525        return this.getReps(10);
526    }
527
528
529    /**
530     * Inserts a repetition of
531     * OBX-10: "Nature of Abnormal Test" at a specific index
532     *
533     * @param rep The repetition index (0-indexed)
534     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
535     */
536    public ID insertNatureOfAbnormalTest(int rep) throws HL7Exception { 
537        return (ID) super.insertRepetition(10, rep);
538    }
539
540
541    /**
542     * Inserts a repetition of
543     * OBX-10: "Nature of Abnormal Test" at a specific index
544     *
545     * @param rep The repetition index (0-indexed)
546     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
547     */
548    public ID insertObx10_NatureOfAbnormalTest(int rep) throws HL7Exception { 
549        return (ID) super.insertRepetition(10, rep);
550    }
551
552
553    /**
554     * Removes a repetition of
555     * OBX-10: "Nature of Abnormal Test" at a specific index
556     *
557     * @param rep The repetition index (0-indexed)
558     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
559     */
560    public ID removeNatureOfAbnormalTest(int rep) throws HL7Exception { 
561        return (ID) super.removeRepetition(10, rep);
562    }
563
564
565    /**
566     * Removes a repetition of
567     * OBX-10: "Nature of Abnormal Test" at a specific index
568     *
569     * @param rep The repetition index (0-indexed)
570     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
571     */
572    public ID removeObx10_NatureOfAbnormalTest(int rep) throws HL7Exception { 
573        return (ID) super.removeRepetition(10, rep);
574    }
575
576
577
578
579    /**
580     * Returns
581     * OBX-11: "Observation Result Status" - creates it if necessary
582     */
583    public ID getObservationResultStatus() { 
584                ID retVal = this.getTypedField(11, 0);
585                return retVal;
586    }
587    
588    /**
589     * Returns
590     * OBX-11: "Observation Result Status" - creates it if necessary
591     */
592    public ID getObx11_ObservationResultStatus() { 
593                ID retVal = this.getTypedField(11, 0);
594                return retVal;
595    }
596
597
598
599    /**
600     * Returns
601     * OBX-12: "Effective Date of Reference Range" - creates it if necessary
602     */
603    public TS getEffectiveDateOfReferenceRange() { 
604                TS retVal = this.getTypedField(12, 0);
605                return retVal;
606    }
607    
608    /**
609     * Returns
610     * OBX-12: "Effective Date of Reference Range" - creates it if necessary
611     */
612    public TS getObx12_EffectiveDateOfReferenceRange() { 
613                TS retVal = this.getTypedField(12, 0);
614                return retVal;
615    }
616
617
618
619    /**
620     * Returns
621     * OBX-13: "User Defined Access Checks" - creates it if necessary
622     */
623    public ST getUserDefinedAccessChecks() { 
624                ST retVal = this.getTypedField(13, 0);
625                return retVal;
626    }
627    
628    /**
629     * Returns
630     * OBX-13: "User Defined Access Checks" - creates it if necessary
631     */
632    public ST getObx13_UserDefinedAccessChecks() { 
633                ST retVal = this.getTypedField(13, 0);
634                return retVal;
635    }
636
637
638
639    /**
640     * Returns
641     * OBX-14: "Date/Time of the Observation" - creates it if necessary
642     */
643    public TS getDateTimeOfTheObservation() { 
644                TS retVal = this.getTypedField(14, 0);
645                return retVal;
646    }
647    
648    /**
649     * Returns
650     * OBX-14: "Date/Time of the Observation" - creates it if necessary
651     */
652    public TS getObx14_DateTimeOfTheObservation() { 
653                TS retVal = this.getTypedField(14, 0);
654                return retVal;
655    }
656
657
658
659    /**
660     * Returns
661     * OBX-15: "Producer's ID" - creates it if necessary
662     */
663    public CE getProducerSID() { 
664                CE retVal = this.getTypedField(15, 0);
665                return retVal;
666    }
667    
668    /**
669     * Returns
670     * OBX-15: "Producer's ID" - creates it if necessary
671     */
672    public CE getObx15_ProducerSID() { 
673                CE retVal = this.getTypedField(15, 0);
674                return retVal;
675    }
676
677
678    /**
679     * Returns all repetitions of Responsible Observer (OBX-16).
680     */
681    public XCN[] getResponsibleObserver() {
682        XCN[] retVal = this.getTypedField(16, new XCN[0]);
683        return retVal;
684    }
685
686
687    /**
688     * Returns all repetitions of Responsible Observer (OBX-16).
689     */
690    public XCN[] getObx16_ResponsibleObserver() {
691        XCN[] retVal = this.getTypedField(16, new XCN[0]);
692        return retVal;
693    }
694
695
696    /**
697     * Returns a count of the current number of repetitions of Responsible Observer (OBX-16).
698     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
699     * it will return zero.
700     */
701    public int getResponsibleObserverReps() {
702        return this.getReps(16);
703    }
704
705
706    /**
707     * Returns a specific repetition of
708     * OBX-16: "Responsible Observer" - creates it if necessary
709     *
710     * @param rep The repetition index (0-indexed)
711     */
712    public XCN getResponsibleObserver(int rep) { 
713                XCN retVal = this.getTypedField(16, rep);
714                return retVal;
715    }
716
717    /**
718     * Returns a specific repetition of
719     * OBX-16: "Responsible Observer" - creates it if necessary
720     *
721     * @param rep The repetition index (0-indexed)
722     */
723    public XCN getObx16_ResponsibleObserver(int rep) { 
724                XCN retVal = this.getTypedField(16, rep);
725                return retVal;
726    }
727
728    /**
729     * Returns a count of the current number of repetitions of Responsible Observer (OBX-16).
730     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
731     * it will return zero.
732     */
733    public int getObx16_ResponsibleObserverReps() {
734        return this.getReps(16);
735    }
736
737
738    /**
739     * Inserts a repetition of
740     * OBX-16: "Responsible Observer" at a specific index
741     *
742     * @param rep The repetition index (0-indexed)
743     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
744     */
745    public XCN insertResponsibleObserver(int rep) throws HL7Exception { 
746        return (XCN) super.insertRepetition(16, rep);
747    }
748
749
750    /**
751     * Inserts a repetition of
752     * OBX-16: "Responsible Observer" at a specific index
753     *
754     * @param rep The repetition index (0-indexed)
755     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
756     */
757    public XCN insertObx16_ResponsibleObserver(int rep) throws HL7Exception { 
758        return (XCN) super.insertRepetition(16, rep);
759    }
760
761
762    /**
763     * Removes a repetition of
764     * OBX-16: "Responsible Observer" at a specific index
765     *
766     * @param rep The repetition index (0-indexed)
767     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
768     */
769    public XCN removeResponsibleObserver(int rep) throws HL7Exception { 
770        return (XCN) super.removeRepetition(16, rep);
771    }
772
773
774    /**
775     * Removes a repetition of
776     * OBX-16: "Responsible Observer" at a specific index
777     *
778     * @param rep The repetition index (0-indexed)
779     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
780     */
781    public XCN removeObx16_ResponsibleObserver(int rep) throws HL7Exception { 
782        return (XCN) super.removeRepetition(16, rep);
783    }
784
785
786
787    /**
788     * Returns all repetitions of Observation Method (OBX-17).
789     */
790    public CE[] getObservationMethod() {
791        CE[] retVal = this.getTypedField(17, new CE[0]);
792        return retVal;
793    }
794
795
796    /**
797     * Returns all repetitions of Observation Method (OBX-17).
798     */
799    public CE[] getObx17_ObservationMethod() {
800        CE[] retVal = this.getTypedField(17, new CE[0]);
801        return retVal;
802    }
803
804
805    /**
806     * Returns a count of the current number of repetitions of Observation Method (OBX-17).
807     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
808     * it will return zero.
809     */
810    public int getObservationMethodReps() {
811        return this.getReps(17);
812    }
813
814
815    /**
816     * Returns a specific repetition of
817     * OBX-17: "Observation Method" - creates it if necessary
818     *
819     * @param rep The repetition index (0-indexed)
820     */
821    public CE getObservationMethod(int rep) { 
822                CE retVal = this.getTypedField(17, rep);
823                return retVal;
824    }
825
826    /**
827     * Returns a specific repetition of
828     * OBX-17: "Observation Method" - creates it if necessary
829     *
830     * @param rep The repetition index (0-indexed)
831     */
832    public CE getObx17_ObservationMethod(int rep) { 
833                CE retVal = this.getTypedField(17, rep);
834                return retVal;
835    }
836
837    /**
838     * Returns a count of the current number of repetitions of Observation Method (OBX-17).
839     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
840     * it will return zero.
841     */
842    public int getObx17_ObservationMethodReps() {
843        return this.getReps(17);
844    }
845
846
847    /**
848     * Inserts a repetition of
849     * OBX-17: "Observation Method" at a specific index
850     *
851     * @param rep The repetition index (0-indexed)
852     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
853     */
854    public CE insertObservationMethod(int rep) throws HL7Exception { 
855        return (CE) super.insertRepetition(17, rep);
856    }
857
858
859    /**
860     * Inserts a repetition of
861     * OBX-17: "Observation Method" at a specific index
862     *
863     * @param rep The repetition index (0-indexed)
864     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
865     */
866    public CE insertObx17_ObservationMethod(int rep) throws HL7Exception { 
867        return (CE) super.insertRepetition(17, rep);
868    }
869
870
871    /**
872     * Removes a repetition of
873     * OBX-17: "Observation Method" at a specific index
874     *
875     * @param rep The repetition index (0-indexed)
876     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
877     */
878    public CE removeObservationMethod(int rep) throws HL7Exception { 
879        return (CE) super.removeRepetition(17, rep);
880    }
881
882
883    /**
884     * Removes a repetition of
885     * OBX-17: "Observation Method" at a specific index
886     *
887     * @param rep The repetition index (0-indexed)
888     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
889     */
890    public CE removeObx17_ObservationMethod(int rep) throws HL7Exception { 
891        return (CE) super.removeRepetition(17, rep);
892    }
893
894
895
896    /**
897     * Returns all repetitions of Equipment Instance Identifier (OBX-18).
898     */
899    public EI[] getEquipmentInstanceIdentifier() {
900        EI[] retVal = this.getTypedField(18, new EI[0]);
901        return retVal;
902    }
903
904
905    /**
906     * Returns all repetitions of Equipment Instance Identifier (OBX-18).
907     */
908    public EI[] getObx18_EquipmentInstanceIdentifier() {
909        EI[] retVal = this.getTypedField(18, new EI[0]);
910        return retVal;
911    }
912
913
914    /**
915     * Returns a count of the current number of repetitions of Equipment Instance Identifier (OBX-18).
916     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
917     * it will return zero.
918     */
919    public int getEquipmentInstanceIdentifierReps() {
920        return this.getReps(18);
921    }
922
923
924    /**
925     * Returns a specific repetition of
926     * OBX-18: "Equipment Instance Identifier" - creates it if necessary
927     *
928     * @param rep The repetition index (0-indexed)
929     */
930    public EI getEquipmentInstanceIdentifier(int rep) { 
931                EI retVal = this.getTypedField(18, rep);
932                return retVal;
933    }
934
935    /**
936     * Returns a specific repetition of
937     * OBX-18: "Equipment Instance Identifier" - creates it if necessary
938     *
939     * @param rep The repetition index (0-indexed)
940     */
941    public EI getObx18_EquipmentInstanceIdentifier(int rep) { 
942                EI retVal = this.getTypedField(18, rep);
943                return retVal;
944    }
945
946    /**
947     * Returns a count of the current number of repetitions of Equipment Instance Identifier (OBX-18).
948     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
949     * it will return zero.
950     */
951    public int getObx18_EquipmentInstanceIdentifierReps() {
952        return this.getReps(18);
953    }
954
955
956    /**
957     * Inserts a repetition of
958     * OBX-18: "Equipment Instance Identifier" at a specific index
959     *
960     * @param rep The repetition index (0-indexed)
961     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
962     */
963    public EI insertEquipmentInstanceIdentifier(int rep) throws HL7Exception { 
964        return (EI) super.insertRepetition(18, rep);
965    }
966
967
968    /**
969     * Inserts a repetition of
970     * OBX-18: "Equipment Instance Identifier" at a specific index
971     *
972     * @param rep The repetition index (0-indexed)
973     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
974     */
975    public EI insertObx18_EquipmentInstanceIdentifier(int rep) throws HL7Exception { 
976        return (EI) super.insertRepetition(18, rep);
977    }
978
979
980    /**
981     * Removes a repetition of
982     * OBX-18: "Equipment Instance Identifier" at a specific index
983     *
984     * @param rep The repetition index (0-indexed)
985     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
986     */
987    public EI removeEquipmentInstanceIdentifier(int rep) throws HL7Exception { 
988        return (EI) super.removeRepetition(18, rep);
989    }
990
991
992    /**
993     * Removes a repetition of
994     * OBX-18: "Equipment Instance Identifier" at a specific index
995     *
996     * @param rep The repetition index (0-indexed)
997     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
998     */
999    public EI removeObx18_EquipmentInstanceIdentifier(int rep) throws HL7Exception { 
1000        return (EI) super.removeRepetition(18, rep);
1001    }
1002
1003
1004
1005
1006    /**
1007     * Returns
1008     * OBX-19: "Date/Time of the Analysis" - creates it if necessary
1009     */
1010    public TS getDateTimeOfTheAnalysis() { 
1011                TS retVal = this.getTypedField(19, 0);
1012                return retVal;
1013    }
1014    
1015    /**
1016     * Returns
1017     * OBX-19: "Date/Time of the Analysis" - creates it if necessary
1018     */
1019    public TS getObx19_DateTimeOfTheAnalysis() { 
1020                TS retVal = this.getTypedField(19, 0);
1021                return retVal;
1022    }
1023
1024
1025
1026
1027
1028    /** {@inheritDoc} */   
1029    protected Type createNewTypeWithoutReflection(int field) {
1030       switch (field) {
1031          case 0: return new SI(getMessage());
1032          case 1: return new ID(getMessage(), new Integer( 125 ));
1033          case 2: return new CE(getMessage());
1034          case 3: return new ST(getMessage());
1035          case 4: return new Varies(getMessage());
1036          case 5: return new CE(getMessage());
1037          case 6: return new ST(getMessage());
1038          case 7: return new IS(getMessage(), new Integer( 78 ));
1039          case 8: return new NM(getMessage());
1040          case 9: return new ID(getMessage(), new Integer( 80 ));
1041          case 10: return new ID(getMessage(), new Integer( 85 ));
1042          case 11: return new TS(getMessage());
1043          case 12: return new ST(getMessage());
1044          case 13: return new TS(getMessage());
1045          case 14: return new CE(getMessage());
1046          case 15: return new XCN(getMessage());
1047          case 16: return new CE(getMessage());
1048          case 17: return new EI(getMessage());
1049          case 18: return new TS(getMessage());
1050          default: return null;
1051       }
1052   }
1053
1054
1055}
1056