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.v251.segment;
035
036// import ca.uhn.hl7v2.model.v251.group.*;
037import ca.uhn.hl7v2.model.v251.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 QRF message segment (Original style query filter). 
049 * This segment has the following fields:</p>
050 * <ul>
051     * <li>QRF-1: Where Subject Filter (ST) <b> repeating</b>
052     * <li>QRF-2: When Data Start Date/Time (TS) <b>optional </b>
053     * <li>QRF-3: When Data End Date/Time (TS) <b>optional </b>
054     * <li>QRF-4: What User Qualifier (ST) <b>optional repeating</b>
055     * <li>QRF-5: Other QRY Subject Filter (ST) <b>optional repeating</b>
056     * <li>QRF-6: Which Date/Time Qualifier (ID) <b>optional repeating</b>
057     * <li>QRF-7: Which Date/Time Status Qualifier (ID) <b>optional repeating</b>
058     * <li>QRF-8: Date/Time Selection Qualifier (ID) <b>optional repeating</b>
059     * <li>QRF-9: When Quantity/Timing Qualifier (TQ) <b>optional </b>
060     * <li>QRF-10: Search Confidence Threshold (NM) <b>optional </b>
061 * </ul>
062 */
063@SuppressWarnings("unused")
064public class QRF extends AbstractSegment {
065
066    /** 
067     * Creates a new QRF segment
068     */
069    public QRF(Group parent, ModelClassFactory factory) {
070       super(parent, factory);
071       init(factory);
072    }
073
074    private void init(ModelClassFactory factory) {
075       try {
076                                  this.add(ST.class, true, 0, 20, new Object[]{ getMessage() }, "Where Subject Filter");
077                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "When Data Start Date/Time");
078                                  this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "When Data End Date/Time");
079                                  this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "What User Qualifier");
080                                  this.add(ST.class, false, 0, 60, new Object[]{ getMessage() }, "Other QRY Subject Filter");
081                                              this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(156) }, "Which Date/Time Qualifier");
082                                              this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(157) }, "Which Date/Time Status Qualifier");
083                                              this.add(ID.class, false, 0, 12, new Object[]{ getMessage(), new Integer(158) }, "Date/Time Selection Qualifier");
084                                  this.add(TQ.class, false, 1, 60, new Object[]{ getMessage() }, "When Quantity/Timing Qualifier");
085                                  this.add(NM.class, false, 1, 10, new Object[]{ getMessage() }, "Search Confidence Threshold");
086       } catch(HL7Exception e) {
087          log.error("Unexpected error creating QRF - this is probably a bug in the source code generator.", e);
088       }
089    }
090
091
092    /**
093     * Returns all repetitions of Where Subject Filter (QRF-1).
094     */
095    public ST[] getWhereSubjectFilter() {
096        ST[] retVal = this.getTypedField(1, new ST[0]);
097        return retVal;
098    }
099
100
101    /**
102     * Returns all repetitions of Where Subject Filter (QRF-1).
103     */
104    public ST[] getQrf1_WhereSubjectFilter() {
105        ST[] retVal = this.getTypedField(1, new ST[0]);
106        return retVal;
107    }
108
109
110    /**
111     * Returns a count of the current number of repetitions of Where Subject Filter (QRF-1).
112     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
113     * it will return zero.
114     */
115    public int getWhereSubjectFilterReps() {
116        return this.getReps(1);
117    }
118
119
120    /**
121     * Returns a specific repetition of
122     * QRF-1: "Where Subject Filter" - creates it if necessary
123     *
124     * @param rep The repetition index (0-indexed)
125     */
126    public ST getWhereSubjectFilter(int rep) { 
127                ST retVal = this.getTypedField(1, rep);
128                return retVal;
129    }
130
131    /**
132     * Returns a specific repetition of
133     * QRF-1: "Where Subject Filter" - creates it if necessary
134     *
135     * @param rep The repetition index (0-indexed)
136     */
137    public ST getQrf1_WhereSubjectFilter(int rep) { 
138                ST retVal = this.getTypedField(1, rep);
139                return retVal;
140    }
141
142    /**
143     * Returns a count of the current number of repetitions of Where Subject Filter (QRF-1).
144     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
145     * it will return zero.
146     */
147    public int getQrf1_WhereSubjectFilterReps() {
148        return this.getReps(1);
149    }
150
151
152    /**
153     * Inserts a repetition of
154     * QRF-1: "Where Subject Filter" at a specific index
155     *
156     * @param rep The repetition index (0-indexed)
157     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
158     */
159    public ST insertWhereSubjectFilter(int rep) throws HL7Exception { 
160        return (ST) super.insertRepetition(1, rep);
161    }
162
163
164    /**
165     * Inserts a repetition of
166     * QRF-1: "Where Subject Filter" at a specific index
167     *
168     * @param rep The repetition index (0-indexed)
169     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
170     */
171    public ST insertQrf1_WhereSubjectFilter(int rep) throws HL7Exception { 
172        return (ST) super.insertRepetition(1, rep);
173    }
174
175
176    /**
177     * Removes a repetition of
178     * QRF-1: "Where Subject Filter" at a specific index
179     *
180     * @param rep The repetition index (0-indexed)
181     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
182     */
183    public ST removeWhereSubjectFilter(int rep) throws HL7Exception { 
184        return (ST) super.removeRepetition(1, rep);
185    }
186
187
188    /**
189     * Removes a repetition of
190     * QRF-1: "Where Subject Filter" at a specific index
191     *
192     * @param rep The repetition index (0-indexed)
193     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
194     */
195    public ST removeQrf1_WhereSubjectFilter(int rep) throws HL7Exception { 
196        return (ST) super.removeRepetition(1, rep);
197    }
198
199
200
201
202    /**
203     * Returns
204     * QRF-2: "When Data Start Date/Time" - creates it if necessary
205     */
206    public TS getWhenDataStartDateTime() { 
207                TS retVal = this.getTypedField(2, 0);
208                return retVal;
209    }
210    
211    /**
212     * Returns
213     * QRF-2: "When Data Start Date/Time" - creates it if necessary
214     */
215    public TS getQrf2_WhenDataStartDateTime() { 
216                TS retVal = this.getTypedField(2, 0);
217                return retVal;
218    }
219
220
221
222    /**
223     * Returns
224     * QRF-3: "When Data End Date/Time" - creates it if necessary
225     */
226    public TS getWhenDataEndDateTime() { 
227                TS retVal = this.getTypedField(3, 0);
228                return retVal;
229    }
230    
231    /**
232     * Returns
233     * QRF-3: "When Data End Date/Time" - creates it if necessary
234     */
235    public TS getQrf3_WhenDataEndDateTime() { 
236                TS retVal = this.getTypedField(3, 0);
237                return retVal;
238    }
239
240
241    /**
242     * Returns all repetitions of What User Qualifier (QRF-4).
243     */
244    public ST[] getWhatUserQualifier() {
245        ST[] retVal = this.getTypedField(4, new ST[0]);
246        return retVal;
247    }
248
249
250    /**
251     * Returns all repetitions of What User Qualifier (QRF-4).
252     */
253    public ST[] getQrf4_WhatUserQualifier() {
254        ST[] retVal = this.getTypedField(4, new ST[0]);
255        return retVal;
256    }
257
258
259    /**
260     * Returns a count of the current number of repetitions of What User Qualifier (QRF-4).
261     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
262     * it will return zero.
263     */
264    public int getWhatUserQualifierReps() {
265        return this.getReps(4);
266    }
267
268
269    /**
270     * Returns a specific repetition of
271     * QRF-4: "What User Qualifier" - creates it if necessary
272     *
273     * @param rep The repetition index (0-indexed)
274     */
275    public ST getWhatUserQualifier(int rep) { 
276                ST retVal = this.getTypedField(4, rep);
277                return retVal;
278    }
279
280    /**
281     * Returns a specific repetition of
282     * QRF-4: "What User Qualifier" - creates it if necessary
283     *
284     * @param rep The repetition index (0-indexed)
285     */
286    public ST getQrf4_WhatUserQualifier(int rep) { 
287                ST retVal = this.getTypedField(4, rep);
288                return retVal;
289    }
290
291    /**
292     * Returns a count of the current number of repetitions of What User Qualifier (QRF-4).
293     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
294     * it will return zero.
295     */
296    public int getQrf4_WhatUserQualifierReps() {
297        return this.getReps(4);
298    }
299
300
301    /**
302     * Inserts a repetition of
303     * QRF-4: "What User Qualifier" 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 ST insertWhatUserQualifier(int rep) throws HL7Exception { 
309        return (ST) super.insertRepetition(4, rep);
310    }
311
312
313    /**
314     * Inserts a repetition of
315     * QRF-4: "What User Qualifier" 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 ST insertQrf4_WhatUserQualifier(int rep) throws HL7Exception { 
321        return (ST) super.insertRepetition(4, rep);
322    }
323
324
325    /**
326     * Removes a repetition of
327     * QRF-4: "What User Qualifier" 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 ST removeWhatUserQualifier(int rep) throws HL7Exception { 
333        return (ST) super.removeRepetition(4, rep);
334    }
335
336
337    /**
338     * Removes a repetition of
339     * QRF-4: "What User Qualifier" at a specific index
340     *
341     * @param rep The repetition index (0-indexed)
342     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
343     */
344    public ST removeQrf4_WhatUserQualifier(int rep) throws HL7Exception { 
345        return (ST) super.removeRepetition(4, rep);
346    }
347
348
349
350    /**
351     * Returns all repetitions of Other QRY Subject Filter (QRF-5).
352     */
353    public ST[] getOtherQRYSubjectFilter() {
354        ST[] retVal = this.getTypedField(5, new ST[0]);
355        return retVal;
356    }
357
358
359    /**
360     * Returns all repetitions of Other QRY Subject Filter (QRF-5).
361     */
362    public ST[] getQrf5_OtherQRYSubjectFilter() {
363        ST[] retVal = this.getTypedField(5, new ST[0]);
364        return retVal;
365    }
366
367
368    /**
369     * Returns a count of the current number of repetitions of Other QRY Subject Filter (QRF-5).
370     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
371     * it will return zero.
372     */
373    public int getOtherQRYSubjectFilterReps() {
374        return this.getReps(5);
375    }
376
377
378    /**
379     * Returns a specific repetition of
380     * QRF-5: "Other QRY Subject Filter" - creates it if necessary
381     *
382     * @param rep The repetition index (0-indexed)
383     */
384    public ST getOtherQRYSubjectFilter(int rep) { 
385                ST retVal = this.getTypedField(5, rep);
386                return retVal;
387    }
388
389    /**
390     * Returns a specific repetition of
391     * QRF-5: "Other QRY Subject Filter" - creates it if necessary
392     *
393     * @param rep The repetition index (0-indexed)
394     */
395    public ST getQrf5_OtherQRYSubjectFilter(int rep) { 
396                ST retVal = this.getTypedField(5, rep);
397                return retVal;
398    }
399
400    /**
401     * Returns a count of the current number of repetitions of Other QRY Subject Filter (QRF-5).
402     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
403     * it will return zero.
404     */
405    public int getQrf5_OtherQRYSubjectFilterReps() {
406        return this.getReps(5);
407    }
408
409
410    /**
411     * Inserts a repetition of
412     * QRF-5: "Other QRY Subject Filter" 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 insertOtherQRYSubjectFilter(int rep) throws HL7Exception { 
418        return (ST) super.insertRepetition(5, rep);
419    }
420
421
422    /**
423     * Inserts a repetition of
424     * QRF-5: "Other QRY Subject Filter" 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 insertQrf5_OtherQRYSubjectFilter(int rep) throws HL7Exception { 
430        return (ST) super.insertRepetition(5, rep);
431    }
432
433
434    /**
435     * Removes a repetition of
436     * QRF-5: "Other QRY Subject Filter" 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 removeOtherQRYSubjectFilter(int rep) throws HL7Exception { 
442        return (ST) super.removeRepetition(5, rep);
443    }
444
445
446    /**
447     * Removes a repetition of
448     * QRF-5: "Other QRY Subject Filter" at a specific index
449     *
450     * @param rep The repetition index (0-indexed)
451     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
452     */
453    public ST removeQrf5_OtherQRYSubjectFilter(int rep) throws HL7Exception { 
454        return (ST) super.removeRepetition(5, rep);
455    }
456
457
458
459    /**
460     * Returns all repetitions of Which Date/Time Qualifier (QRF-6).
461     */
462    public ID[] getWhichDateTimeQualifier() {
463        ID[] retVal = this.getTypedField(6, new ID[0]);
464        return retVal;
465    }
466
467
468    /**
469     * Returns all repetitions of Which Date/Time Qualifier (QRF-6).
470     */
471    public ID[] getQrf6_WhichDateTimeQualifier() {
472        ID[] retVal = this.getTypedField(6, new ID[0]);
473        return retVal;
474    }
475
476
477    /**
478     * Returns a count of the current number of repetitions of Which Date/Time Qualifier (QRF-6).
479     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
480     * it will return zero.
481     */
482    public int getWhichDateTimeQualifierReps() {
483        return this.getReps(6);
484    }
485
486
487    /**
488     * Returns a specific repetition of
489     * QRF-6: "Which Date/Time Qualifier" - creates it if necessary
490     *
491     * @param rep The repetition index (0-indexed)
492     */
493    public ID getWhichDateTimeQualifier(int rep) { 
494                ID retVal = this.getTypedField(6, rep);
495                return retVal;
496    }
497
498    /**
499     * Returns a specific repetition of
500     * QRF-6: "Which Date/Time Qualifier" - creates it if necessary
501     *
502     * @param rep The repetition index (0-indexed)
503     */
504    public ID getQrf6_WhichDateTimeQualifier(int rep) { 
505                ID retVal = this.getTypedField(6, rep);
506                return retVal;
507    }
508
509    /**
510     * Returns a count of the current number of repetitions of Which Date/Time Qualifier (QRF-6).
511     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
512     * it will return zero.
513     */
514    public int getQrf6_WhichDateTimeQualifierReps() {
515        return this.getReps(6);
516    }
517
518
519    /**
520     * Inserts a repetition of
521     * QRF-6: "Which Date/Time Qualifier" at a specific index
522     *
523     * @param rep The repetition index (0-indexed)
524     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
525     */
526    public ID insertWhichDateTimeQualifier(int rep) throws HL7Exception { 
527        return (ID) super.insertRepetition(6, rep);
528    }
529
530
531    /**
532     * Inserts a repetition of
533     * QRF-6: "Which Date/Time Qualifier" at a specific index
534     *
535     * @param rep The repetition index (0-indexed)
536     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
537     */
538    public ID insertQrf6_WhichDateTimeQualifier(int rep) throws HL7Exception { 
539        return (ID) super.insertRepetition(6, rep);
540    }
541
542
543    /**
544     * Removes a repetition of
545     * QRF-6: "Which Date/Time Qualifier" at a specific index
546     *
547     * @param rep The repetition index (0-indexed)
548     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
549     */
550    public ID removeWhichDateTimeQualifier(int rep) throws HL7Exception { 
551        return (ID) super.removeRepetition(6, rep);
552    }
553
554
555    /**
556     * Removes a repetition of
557     * QRF-6: "Which Date/Time Qualifier" at a specific index
558     *
559     * @param rep The repetition index (0-indexed)
560     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
561     */
562    public ID removeQrf6_WhichDateTimeQualifier(int rep) throws HL7Exception { 
563        return (ID) super.removeRepetition(6, rep);
564    }
565
566
567
568    /**
569     * Returns all repetitions of Which Date/Time Status Qualifier (QRF-7).
570     */
571    public ID[] getWhichDateTimeStatusQualifier() {
572        ID[] retVal = this.getTypedField(7, new ID[0]);
573        return retVal;
574    }
575
576
577    /**
578     * Returns all repetitions of Which Date/Time Status Qualifier (QRF-7).
579     */
580    public ID[] getQrf7_WhichDateTimeStatusQualifier() {
581        ID[] retVal = this.getTypedField(7, new ID[0]);
582        return retVal;
583    }
584
585
586    /**
587     * Returns a count of the current number of repetitions of Which Date/Time Status Qualifier (QRF-7).
588     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
589     * it will return zero.
590     */
591    public int getWhichDateTimeStatusQualifierReps() {
592        return this.getReps(7);
593    }
594
595
596    /**
597     * Returns a specific repetition of
598     * QRF-7: "Which Date/Time Status Qualifier" - creates it if necessary
599     *
600     * @param rep The repetition index (0-indexed)
601     */
602    public ID getWhichDateTimeStatusQualifier(int rep) { 
603                ID retVal = this.getTypedField(7, rep);
604                return retVal;
605    }
606
607    /**
608     * Returns a specific repetition of
609     * QRF-7: "Which Date/Time Status Qualifier" - creates it if necessary
610     *
611     * @param rep The repetition index (0-indexed)
612     */
613    public ID getQrf7_WhichDateTimeStatusQualifier(int rep) { 
614                ID retVal = this.getTypedField(7, rep);
615                return retVal;
616    }
617
618    /**
619     * Returns a count of the current number of repetitions of Which Date/Time Status Qualifier (QRF-7).
620     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
621     * it will return zero.
622     */
623    public int getQrf7_WhichDateTimeStatusQualifierReps() {
624        return this.getReps(7);
625    }
626
627
628    /**
629     * Inserts a repetition of
630     * QRF-7: "Which Date/Time Status Qualifier" at a specific index
631     *
632     * @param rep The repetition index (0-indexed)
633     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
634     */
635    public ID insertWhichDateTimeStatusQualifier(int rep) throws HL7Exception { 
636        return (ID) super.insertRepetition(7, rep);
637    }
638
639
640    /**
641     * Inserts a repetition of
642     * QRF-7: "Which Date/Time Status Qualifier" at a specific index
643     *
644     * @param rep The repetition index (0-indexed)
645     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
646     */
647    public ID insertQrf7_WhichDateTimeStatusQualifier(int rep) throws HL7Exception { 
648        return (ID) super.insertRepetition(7, rep);
649    }
650
651
652    /**
653     * Removes a repetition of
654     * QRF-7: "Which Date/Time Status Qualifier" at a specific index
655     *
656     * @param rep The repetition index (0-indexed)
657     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
658     */
659    public ID removeWhichDateTimeStatusQualifier(int rep) throws HL7Exception { 
660        return (ID) super.removeRepetition(7, rep);
661    }
662
663
664    /**
665     * Removes a repetition of
666     * QRF-7: "Which Date/Time Status Qualifier" at a specific index
667     *
668     * @param rep The repetition index (0-indexed)
669     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
670     */
671    public ID removeQrf7_WhichDateTimeStatusQualifier(int rep) throws HL7Exception { 
672        return (ID) super.removeRepetition(7, rep);
673    }
674
675
676
677    /**
678     * Returns all repetitions of Date/Time Selection Qualifier (QRF-8).
679     */
680    public ID[] getDateTimeSelectionQualifier() {
681        ID[] retVal = this.getTypedField(8, new ID[0]);
682        return retVal;
683    }
684
685
686    /**
687     * Returns all repetitions of Date/Time Selection Qualifier (QRF-8).
688     */
689    public ID[] getQrf8_DateTimeSelectionQualifier() {
690        ID[] retVal = this.getTypedField(8, new ID[0]);
691        return retVal;
692    }
693
694
695    /**
696     * Returns a count of the current number of repetitions of Date/Time Selection Qualifier (QRF-8).
697     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
698     * it will return zero.
699     */
700    public int getDateTimeSelectionQualifierReps() {
701        return this.getReps(8);
702    }
703
704
705    /**
706     * Returns a specific repetition of
707     * QRF-8: "Date/Time Selection Qualifier" - creates it if necessary
708     *
709     * @param rep The repetition index (0-indexed)
710     */
711    public ID getDateTimeSelectionQualifier(int rep) { 
712                ID retVal = this.getTypedField(8, rep);
713                return retVal;
714    }
715
716    /**
717     * Returns a specific repetition of
718     * QRF-8: "Date/Time Selection Qualifier" - creates it if necessary
719     *
720     * @param rep The repetition index (0-indexed)
721     */
722    public ID getQrf8_DateTimeSelectionQualifier(int rep) { 
723                ID retVal = this.getTypedField(8, rep);
724                return retVal;
725    }
726
727    /**
728     * Returns a count of the current number of repetitions of Date/Time Selection Qualifier (QRF-8).
729     * This method does not create a repetition, so if no repetitions have currently been defined or accessed,
730     * it will return zero.
731     */
732    public int getQrf8_DateTimeSelectionQualifierReps() {
733        return this.getReps(8);
734    }
735
736
737    /**
738     * Inserts a repetition of
739     * QRF-8: "Date/Time Selection Qualifier" at a specific index
740     *
741     * @param rep The repetition index (0-indexed)
742     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
743     */
744    public ID insertDateTimeSelectionQualifier(int rep) throws HL7Exception { 
745        return (ID) super.insertRepetition(8, rep);
746    }
747
748
749    /**
750     * Inserts a repetition of
751     * QRF-8: "Date/Time Selection Qualifier" at a specific index
752     *
753     * @param rep The repetition index (0-indexed)
754     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
755     */
756    public ID insertQrf8_DateTimeSelectionQualifier(int rep) throws HL7Exception { 
757        return (ID) super.insertRepetition(8, rep);
758    }
759
760
761    /**
762     * Removes a repetition of
763     * QRF-8: "Date/Time Selection Qualifier" at a specific index
764     *
765     * @param rep The repetition index (0-indexed)
766     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
767     */
768    public ID removeDateTimeSelectionQualifier(int rep) throws HL7Exception { 
769        return (ID) super.removeRepetition(8, rep);
770    }
771
772
773    /**
774     * Removes a repetition of
775     * QRF-8: "Date/Time Selection Qualifier" at a specific index
776     *
777     * @param rep The repetition index (0-indexed)
778     * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions)
779     */
780    public ID removeQrf8_DateTimeSelectionQualifier(int rep) throws HL7Exception { 
781        return (ID) super.removeRepetition(8, rep);
782    }
783
784
785
786
787    /**
788     * Returns
789     * QRF-9: "When Quantity/Timing Qualifier" - creates it if necessary
790     */
791    public TQ getWhenQuantityTimingQualifier() { 
792                TQ retVal = this.getTypedField(9, 0);
793                return retVal;
794    }
795    
796    /**
797     * Returns
798     * QRF-9: "When Quantity/Timing Qualifier" - creates it if necessary
799     */
800    public TQ getQrf9_WhenQuantityTimingQualifier() { 
801                TQ retVal = this.getTypedField(9, 0);
802                return retVal;
803    }
804
805
806
807    /**
808     * Returns
809     * QRF-10: "Search Confidence Threshold" - creates it if necessary
810     */
811    public NM getSearchConfidenceThreshold() { 
812                NM retVal = this.getTypedField(10, 0);
813                return retVal;
814    }
815    
816    /**
817     * Returns
818     * QRF-10: "Search Confidence Threshold" - creates it if necessary
819     */
820    public NM getQrf10_SearchConfidenceThreshold() { 
821                NM retVal = this.getTypedField(10, 0);
822                return retVal;
823    }
824
825
826
827
828
829    /** {@inheritDoc} */   
830    protected Type createNewTypeWithoutReflection(int field) {
831       switch (field) {
832          case 0: return new ST(getMessage());
833          case 1: return new TS(getMessage());
834          case 2: return new TS(getMessage());
835          case 3: return new ST(getMessage());
836          case 4: return new ST(getMessage());
837          case 5: return new ID(getMessage(), new Integer( 156 ));
838          case 6: return new ID(getMessage(), new Integer( 157 ));
839          case 7: return new ID(getMessage(), new Integer( 158 ));
840          case 8: return new TQ(getMessage());
841          case 9: return new NM(getMessage());
842          default: return null;
843       }
844   }
845
846
847}
848