Source code

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