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