1 /*
2 * This class is an auto-generated source file for a HAPI
3 * HL7 v2.x standard structure class.
4 *
5 * For more information, visit: http://hl7api.sourceforge.net/
6 *
7 * The contents of this file are subject to the Mozilla Public License Version 1.1
8 * (the "License"); you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at http://www.mozilla.org/MPL/
10 * Software distributed under the License is distributed on an "AS IS" basis,
11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the
12 * specific language governing rights and limitations under the License.
13 *
14 * The Original Code is "[file_name]". Description:
15 * "[one_line_description]"
16 *
17 * The Initial Developer of the Original Code is University Health Network. Copyright (C)
18 * 2012. All Rights Reserved.
19 *
20 * Contributor(s): ______________________________________.
21 *
22 * Alternatively, the contents of this file may be used under the terms of the
23 * GNU General Public License (the "GPL"), in which case the provisions of the GPL are
24 * applicable instead of those above. If you wish to allow use of your version of this
25 * file only under the terms of the GPL and not to allow others to use your version
26 * of this file under the MPL, indicate your decision by deleting the provisions above
27 * and replace them with the notice and other provisions required by the GPL License.
28 * If you do not delete the provisions above, a recipient may use your version of
29 * this file under either the MPL or the GPL.
30 *
31 */
32
33
34 package ca.uhn.hl7v2.model.v281.message;
35
36 import ca.uhn.hl7v2.model.v281.group.*;
37 import ca.uhn.hl7v2.model.v281.segment.*;
38
39 import ca.uhn.hl7v2.HL7Exception;
40 import ca.uhn.hl7v2.parser.ModelClassFactory;
41 import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
42 import ca.uhn.hl7v2.model.*;
43
44
45 /**
46 * <p>Represents a ORU_R30 message structure (see chapter 7.3.4). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (Message Header) <b> </b> </li>
50 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li>
51 * <li>3: UAC (User Authentication Credential Segment) <b>optional </b> </li>
52 * <li>4: PID (Patient Identification) <b> </b> </li>
53 * <li>5: PD1 (Patient Additional Demographic) <b>optional </b> </li>
54 * <li>6: PRT (Participation Information) <b>optional repeating</b> </li>
55 * <li>7: ARV (Access Restriction) <b>optional repeating</b> </li>
56 * <li>8: ORU_R30_PATIENT_OBSERVATION (a Group object) <b>optional repeating</b> </li>
57 * <li>9: ORU_R30_VISIT (a Group object) <b>optional </b> </li>
58 * <li>10: ORC (Common Order) <b> </b> </li>
59 * <li>11: PRT (Participation Information) <b>optional repeating</b> </li>
60 * <li>12: OBR (Observation Request) <b> </b> </li>
61 * <li>13: NTE (Notes and Comments) <b>optional repeating</b> </li>
62 * <li>14: PRT (Participation Information) <b>optional repeating</b> </li>
63 * <li>15: ORU_R30_TIMING_QTY (a Group object) <b>optional repeating</b> </li>
64 * <li>16: ORU_R30_OBSERVATION (a Group object) <b> repeating</b> </li>
65 * </ul>
66 */
67 //@SuppressWarnings("unused")
68 public class ORU_R30 extends AbstractMessage {
69
70 /**
71 * Creates a new ORU_R30 message with DefaultModelClassFactory.
72 */
73 public ORU_R30() {
74 this(new DefaultModelClassFactory());
75 }
76
77 /**
78 * Creates a new ORU_R30 message with custom ModelClassFactory.
79 */
80 public ORU_R30(ModelClassFactory factory) {
81 super(factory);
82 init(factory);
83 }
84
85 private void init(ModelClassFactory factory) {
86 try {
87 this.add(MSH.class, true, false);
88 this.add(SFT.class, false, true);
89 this.add(UAC.class, false, false);
90 this.add(PID.class, true, false);
91 this.add(PD1.class, false, false);
92 this.add(PRT.class, false, true);
93 this.add(ARV.class, false, true);
94 this.add(ORU_R30_PATIENT_OBSERVATION.class, false, true);
95 this.add(ORU_R30_VISIT.class, false, false);
96 this.add(ORC.class, true, false);
97 this.add(PRT.class, false, true);
98 this.add(OBR.class, true, false);
99 this.add(NTE.class, false, true);
100 this.add(PRT.class, false, true);
101 this.add(ORU_R30_TIMING_QTY.class, false, true);
102 this.add(ORU_R30_OBSERVATION.class, true, true);
103 } catch(HL7Exception e) {
104 log.error("Unexpected error creating ORU_R30 - this is probably a bug in the source code generator.", e);
105 }
106 }
107
108
109 /**
110 * Returns "2.8.1"
111 */
112 public String getVersion() {
113 return "2.8.1";
114 }
115
116
117
118
119 /**
120 * <p>
121 * Returns
122 * MSH (Message Header) - creates it if necessary
123 * </p>
124 *
125 *
126 */
127 public MSH getMSH() {
128 return getTyped("MSH", MSH.class);
129 }
130
131
132
133
134
135 /**
136 * <p>
137 * Returns
138 * the first repetition of
139 * SFT (Software Segment) - creates it if necessary
140 * </p>
141 *
142 *
143 */
144 public SFT getSFT() {
145 return getTyped("SFT", SFT.class);
146 }
147
148
149 /**
150 * <p>
151 * Returns a specific repetition of
152 * SFT (Software Segment) - creates it if necessary
153 * </p>
154 *
155 *
156 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
157 * @throws HL7Exception if the repetition requested is more than one
158 * greater than the number of existing repetitions.
159 */
160 public SFT getSFT(int rep) {
161 return getTyped("SFT", rep, SFT.class);
162 }
163
164 /**
165 * <p>
166 * Returns the number of existing repetitions of SFT
167 * </p>
168 *
169 */
170 public int getSFTReps() {
171 return getReps("SFT");
172 }
173
174 /**
175 * <p>
176 * Returns a non-modifiable List containing all current existing repetitions of SFT.
177 * <p>
178 * <p>
179 * Note that unlike {@link #getSFT()}, this method will not create any reps
180 * if none are already present, so an empty list may be returned.
181 * </p>
182 *
183 */
184 public java.util.List<SFT> getSFTAll() throws HL7Exception {
185 return getAllAsList("SFT", SFT.class);
186 }
187
188 /**
189 * <p>
190 * Inserts a specific repetition of SFT (Software Segment)
191 * </p>
192 *
193 *
194 * @see AbstractGroup#insertRepetition(Structure, int)
195 */
196 public void insertSFT(SFT structure, int rep) throws HL7Exception {
197 super.insertRepetition( "SFT", structure, rep);
198 }
199
200
201 /**
202 * <p>
203 * Inserts a specific repetition of SFT (Software Segment)
204 * </p>
205 *
206 *
207 * @see AbstractGroup#insertRepetition(Structure, int)
208 */
209 public SFT insertSFT(int rep) throws HL7Exception {
210 return (SFT)super.insertRepetition("SFT", rep);
211 }
212
213
214 /**
215 * <p>
216 * Removes a specific repetition of SFT (Software Segment)
217 * </p>
218 *
219 *
220 * @see AbstractGroup#removeRepetition(String, int)
221 */
222 public SFT removeSFT(int rep) throws HL7Exception {
223 return (SFT)super.removeRepetition("SFT", rep);
224 }
225
226
227
228
229 /**
230 * <p>
231 * Returns
232 * UAC (User Authentication Credential Segment) - creates it if necessary
233 * </p>
234 *
235 *
236 */
237 public UAC getUAC() {
238 return getTyped("UAC", UAC.class);
239 }
240
241
242
243
244
245 /**
246 * <p>
247 * Returns
248 * PID (Patient Identification) - creates it if necessary
249 * </p>
250 *
251 *
252 */
253 public PID getPID() {
254 return getTyped("PID", PID.class);
255 }
256
257
258
259
260
261 /**
262 * <p>
263 * Returns
264 * PD1 (Patient Additional Demographic) - creates it if necessary
265 * </p>
266 *
267 *
268 */
269 public PD1 getPD1() {
270 return getTyped("PD1", PD1.class);
271 }
272
273
274
275
276
277 /**
278 * <p>
279 * Returns
280 * the first repetition of
281 * PRT (Participation Information) - creates it if necessary
282 * </p>
283 *
284 *
285 */
286 public PRT getPRT() {
287 return getTyped("PRT", PRT.class);
288 }
289
290
291 /**
292 * <p>
293 * Returns a specific repetition of
294 * PRT (Participation Information) - creates it if necessary
295 * </p>
296 *
297 *
298 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
299 * @throws HL7Exception if the repetition requested is more than one
300 * greater than the number of existing repetitions.
301 */
302 public PRT getPRT(int rep) {
303 return getTyped("PRT", rep, PRT.class);
304 }
305
306 /**
307 * <p>
308 * Returns the number of existing repetitions of PRT
309 * </p>
310 *
311 */
312 public int getPRTReps() {
313 return getReps("PRT");
314 }
315
316 /**
317 * <p>
318 * Returns a non-modifiable List containing all current existing repetitions of PRT.
319 * <p>
320 * <p>
321 * Note that unlike {@link #getPRT()}, this method will not create any reps
322 * if none are already present, so an empty list may be returned.
323 * </p>
324 *
325 */
326 public java.util.List<PRT> getPRTAll() throws HL7Exception {
327 return getAllAsList("PRT", PRT.class);
328 }
329
330 /**
331 * <p>
332 * Inserts a specific repetition of PRT (Participation Information)
333 * </p>
334 *
335 *
336 * @see AbstractGroup#insertRepetition(Structure, int)
337 */
338 public void insertPRT(PRT structure, int rep) throws HL7Exception {
339 super.insertRepetition( "PRT", structure, rep);
340 }
341
342
343 /**
344 * <p>
345 * Inserts a specific repetition of PRT (Participation Information)
346 * </p>
347 *
348 *
349 * @see AbstractGroup#insertRepetition(Structure, int)
350 */
351 public PRT insertPRT(int rep) throws HL7Exception {
352 return (PRT)super.insertRepetition("PRT", rep);
353 }
354
355
356 /**
357 * <p>
358 * Removes a specific repetition of PRT (Participation Information)
359 * </p>
360 *
361 *
362 * @see AbstractGroup#removeRepetition(String, int)
363 */
364 public PRT removePRT(int rep) throws HL7Exception {
365 return (PRT)super.removeRepetition("PRT", rep);
366 }
367
368
369
370
371 /**
372 * <p>
373 * Returns
374 * the first repetition of
375 * ARV (Access Restriction) - creates it if necessary
376 * </p>
377 *
378 *
379 */
380 public ARV getARV() {
381 return getTyped("ARV", ARV.class);
382 }
383
384
385 /**
386 * <p>
387 * Returns a specific repetition of
388 * ARV (Access Restriction) - creates it if necessary
389 * </p>
390 *
391 *
392 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
393 * @throws HL7Exception if the repetition requested is more than one
394 * greater than the number of existing repetitions.
395 */
396 public ARV getARV(int rep) {
397 return getTyped("ARV", rep, ARV.class);
398 }
399
400 /**
401 * <p>
402 * Returns the number of existing repetitions of ARV
403 * </p>
404 *
405 */
406 public int getARVReps() {
407 return getReps("ARV");
408 }
409
410 /**
411 * <p>
412 * Returns a non-modifiable List containing all current existing repetitions of ARV.
413 * <p>
414 * <p>
415 * Note that unlike {@link #getARV()}, this method will not create any reps
416 * if none are already present, so an empty list may be returned.
417 * </p>
418 *
419 */
420 public java.util.List<ARV> getARVAll() throws HL7Exception {
421 return getAllAsList("ARV", ARV.class);
422 }
423
424 /**
425 * <p>
426 * Inserts a specific repetition of ARV (Access Restriction)
427 * </p>
428 *
429 *
430 * @see AbstractGroup#insertRepetition(Structure, int)
431 */
432 public void insertARV(ARV structure, int rep) throws HL7Exception {
433 super.insertRepetition( "ARV", structure, rep);
434 }
435
436
437 /**
438 * <p>
439 * Inserts a specific repetition of ARV (Access Restriction)
440 * </p>
441 *
442 *
443 * @see AbstractGroup#insertRepetition(Structure, int)
444 */
445 public ARV insertARV(int rep) throws HL7Exception {
446 return (ARV)super.insertRepetition("ARV", rep);
447 }
448
449
450 /**
451 * <p>
452 * Removes a specific repetition of ARV (Access Restriction)
453 * </p>
454 *
455 *
456 * @see AbstractGroup#removeRepetition(String, int)
457 */
458 public ARV removeARV(int rep) throws HL7Exception {
459 return (ARV)super.removeRepetition("ARV", rep);
460 }
461
462
463
464
465 /**
466 * <p>
467 * Returns
468 * the first repetition of
469 * PATIENT_OBSERVATION (a Group object) - creates it if necessary
470 * </p>
471 *
472 *
473 */
474 public ORU_R30_PATIENT_OBSERVATION getPATIENT_OBSERVATION() {
475 return getTyped("PATIENT_OBSERVATION", ORU_R30_PATIENT_OBSERVATION.class);
476 }
477
478
479 /**
480 * <p>
481 * Returns a specific repetition of
482 * PATIENT_OBSERVATION (a Group object) - creates it if necessary
483 * </p>
484 *
485 *
486 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
487 * @throws HL7Exception if the repetition requested is more than one
488 * greater than the number of existing repetitions.
489 */
490 public ORU_R30_PATIENT_OBSERVATION getPATIENT_OBSERVATION(int rep) {
491 return getTyped("PATIENT_OBSERVATION", rep, ORU_R30_PATIENT_OBSERVATION.class);
492 }
493
494 /**
495 * <p>
496 * Returns the number of existing repetitions of PATIENT_OBSERVATION
497 * </p>
498 *
499 */
500 public int getPATIENT_OBSERVATIONReps() {
501 return getReps("PATIENT_OBSERVATION");
502 }
503
504 /**
505 * <p>
506 * Returns a non-modifiable List containing all current existing repetitions of PATIENT_OBSERVATION.
507 * <p>
508 * <p>
509 * Note that unlike {@link #getPATIENT_OBSERVATION()}, this method will not create any reps
510 * if none are already present, so an empty list may be returned.
511 * </p>
512 *
513 */
514 public java.util.List<ORU_R30_PATIENT_OBSERVATION> getPATIENT_OBSERVATIONAll() throws HL7Exception {
515 return getAllAsList("PATIENT_OBSERVATION", ORU_R30_PATIENT_OBSERVATION.class);
516 }
517
518 /**
519 * <p>
520 * Inserts a specific repetition of PATIENT_OBSERVATION (a Group object)
521 * </p>
522 *
523 *
524 * @see AbstractGroup#insertRepetition(Structure, int)
525 */
526 public void insertPATIENT_OBSERVATION(ORU_R30_PATIENT_OBSERVATION structure, int rep) throws HL7Exception {
527 super.insertRepetition( "PATIENT_OBSERVATION", structure, rep);
528 }
529
530
531 /**
532 * <p>
533 * Inserts a specific repetition of PATIENT_OBSERVATION (a Group object)
534 * </p>
535 *
536 *
537 * @see AbstractGroup#insertRepetition(Structure, int)
538 */
539 public ORU_R30_PATIENT_OBSERVATION insertPATIENT_OBSERVATION(int rep) throws HL7Exception {
540 return (ORU_R30_PATIENT_OBSERVATION)super.insertRepetition("PATIENT_OBSERVATION", rep);
541 }
542
543
544 /**
545 * <p>
546 * Removes a specific repetition of PATIENT_OBSERVATION (a Group object)
547 * </p>
548 *
549 *
550 * @see AbstractGroup#removeRepetition(String, int)
551 */
552 public ORU_R30_PATIENT_OBSERVATION removePATIENT_OBSERVATION(int rep) throws HL7Exception {
553 return (ORU_R30_PATIENT_OBSERVATION)super.removeRepetition("PATIENT_OBSERVATION", rep);
554 }
555
556
557
558
559 /**
560 * <p>
561 * Returns
562 * VISIT (a Group object) - creates it if necessary
563 * </p>
564 *
565 *
566 */
567 public ORU_R30_VISIT getVISIT() {
568 return getTyped("VISIT", ORU_R30_VISIT.class);
569 }
570
571
572
573
574
575 /**
576 * <p>
577 * Returns
578 * ORC (Common Order) - creates it if necessary
579 * </p>
580 *
581 *
582 */
583 public ORC getORC() {
584 return getTyped("ORC", ORC.class);
585 }
586
587
588
589
590
591 /**
592 * <p>
593 * Returns
594 * the first repetition of
595 * PRT2 (Participation Information) - creates it if necessary
596 * </p>
597 *
598 *
599 */
600 public PRT getPRT2() {
601 return getTyped("PRT2", PRT.class);
602 }
603
604
605 /**
606 * <p>
607 * Returns a specific repetition of
608 * PRT2 (Participation Information) - creates it if necessary
609 * </p>
610 *
611 *
612 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
613 * @throws HL7Exception if the repetition requested is more than one
614 * greater than the number of existing repetitions.
615 */
616 public PRT getPRT2(int rep) {
617 return getTyped("PRT2", rep, PRT.class);
618 }
619
620 /**
621 * <p>
622 * Returns the number of existing repetitions of PRT2
623 * </p>
624 *
625 */
626 public int getPRT2Reps() {
627 return getReps("PRT2");
628 }
629
630 /**
631 * <p>
632 * Returns a non-modifiable List containing all current existing repetitions of PRT2.
633 * <p>
634 * <p>
635 * Note that unlike {@link #getPRT2()}, this method will not create any reps
636 * if none are already present, so an empty list may be returned.
637 * </p>
638 *
639 */
640 public java.util.List<PRT> getPRT2All() throws HL7Exception {
641 return getAllAsList("PRT2", PRT.class);
642 }
643
644 /**
645 * <p>
646 * Inserts a specific repetition of PRT2 (Participation Information)
647 * </p>
648 *
649 *
650 * @see AbstractGroup#insertRepetition(Structure, int)
651 */
652 public void insertPRT2(PRT structure, int rep) throws HL7Exception {
653 super.insertRepetition( "PRT2", structure, rep);
654 }
655
656
657 /**
658 * <p>
659 * Inserts a specific repetition of PRT2 (Participation Information)
660 * </p>
661 *
662 *
663 * @see AbstractGroup#insertRepetition(Structure, int)
664 */
665 public PRT insertPRT2(int rep) throws HL7Exception {
666 return (PRT)super.insertRepetition("PRT2", rep);
667 }
668
669
670 /**
671 * <p>
672 * Removes a specific repetition of PRT2 (Participation Information)
673 * </p>
674 *
675 *
676 * @see AbstractGroup#removeRepetition(String, int)
677 */
678 public PRT removePRT2(int rep) throws HL7Exception {
679 return (PRT)super.removeRepetition("PRT2", rep);
680 }
681
682
683
684
685 /**
686 * <p>
687 * Returns
688 * OBR (Observation Request) - creates it if necessary
689 * </p>
690 *
691 *
692 */
693 public OBR getOBR() {
694 return getTyped("OBR", OBR.class);
695 }
696
697
698
699
700
701 /**
702 * <p>
703 * Returns
704 * the first repetition of
705 * NTE (Notes and Comments) - creates it if necessary
706 * </p>
707 *
708 *
709 */
710 public NTE getNTE() {
711 return getTyped("NTE", NTE.class);
712 }
713
714
715 /**
716 * <p>
717 * Returns a specific repetition of
718 * NTE (Notes and Comments) - creates it if necessary
719 * </p>
720 *
721 *
722 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
723 * @throws HL7Exception if the repetition requested is more than one
724 * greater than the number of existing repetitions.
725 */
726 public NTE getNTE(int rep) {
727 return getTyped("NTE", rep, NTE.class);
728 }
729
730 /**
731 * <p>
732 * Returns the number of existing repetitions of NTE
733 * </p>
734 *
735 */
736 public int getNTEReps() {
737 return getReps("NTE");
738 }
739
740 /**
741 * <p>
742 * Returns a non-modifiable List containing all current existing repetitions of NTE.
743 * <p>
744 * <p>
745 * Note that unlike {@link #getNTE()}, this method will not create any reps
746 * if none are already present, so an empty list may be returned.
747 * </p>
748 *
749 */
750 public java.util.List<NTE> getNTEAll() throws HL7Exception {
751 return getAllAsList("NTE", NTE.class);
752 }
753
754 /**
755 * <p>
756 * Inserts a specific repetition of NTE (Notes and Comments)
757 * </p>
758 *
759 *
760 * @see AbstractGroup#insertRepetition(Structure, int)
761 */
762 public void insertNTE(NTE structure, int rep) throws HL7Exception {
763 super.insertRepetition( "NTE", structure, rep);
764 }
765
766
767 /**
768 * <p>
769 * Inserts a specific repetition of NTE (Notes and Comments)
770 * </p>
771 *
772 *
773 * @see AbstractGroup#insertRepetition(Structure, int)
774 */
775 public NTE insertNTE(int rep) throws HL7Exception {
776 return (NTE)super.insertRepetition("NTE", rep);
777 }
778
779
780 /**
781 * <p>
782 * Removes a specific repetition of NTE (Notes and Comments)
783 * </p>
784 *
785 *
786 * @see AbstractGroup#removeRepetition(String, int)
787 */
788 public NTE removeNTE(int rep) throws HL7Exception {
789 return (NTE)super.removeRepetition("NTE", rep);
790 }
791
792
793
794
795 /**
796 * <p>
797 * Returns
798 * the first repetition of
799 * PRT3 (Participation Information) - creates it if necessary
800 * </p>
801 *
802 *
803 */
804 public PRT getPRT3() {
805 return getTyped("PRT3", PRT.class);
806 }
807
808
809 /**
810 * <p>
811 * Returns a specific repetition of
812 * PRT3 (Participation Information) - creates it if necessary
813 * </p>
814 *
815 *
816 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
817 * @throws HL7Exception if the repetition requested is more than one
818 * greater than the number of existing repetitions.
819 */
820 public PRT getPRT3(int rep) {
821 return getTyped("PRT3", rep, PRT.class);
822 }
823
824 /**
825 * <p>
826 * Returns the number of existing repetitions of PRT3
827 * </p>
828 *
829 */
830 public int getPRT3Reps() {
831 return getReps("PRT3");
832 }
833
834 /**
835 * <p>
836 * Returns a non-modifiable List containing all current existing repetitions of PRT3.
837 * <p>
838 * <p>
839 * Note that unlike {@link #getPRT3()}, this method will not create any reps
840 * if none are already present, so an empty list may be returned.
841 * </p>
842 *
843 */
844 public java.util.List<PRT> getPRT3All() throws HL7Exception {
845 return getAllAsList("PRT3", PRT.class);
846 }
847
848 /**
849 * <p>
850 * Inserts a specific repetition of PRT3 (Participation Information)
851 * </p>
852 *
853 *
854 * @see AbstractGroup#insertRepetition(Structure, int)
855 */
856 public void insertPRT3(PRT structure, int rep) throws HL7Exception {
857 super.insertRepetition( "PRT3", structure, rep);
858 }
859
860
861 /**
862 * <p>
863 * Inserts a specific repetition of PRT3 (Participation Information)
864 * </p>
865 *
866 *
867 * @see AbstractGroup#insertRepetition(Structure, int)
868 */
869 public PRT insertPRT3(int rep) throws HL7Exception {
870 return (PRT)super.insertRepetition("PRT3", rep);
871 }
872
873
874 /**
875 * <p>
876 * Removes a specific repetition of PRT3 (Participation Information)
877 * </p>
878 *
879 *
880 * @see AbstractGroup#removeRepetition(String, int)
881 */
882 public PRT removePRT3(int rep) throws HL7Exception {
883 return (PRT)super.removeRepetition("PRT3", rep);
884 }
885
886
887
888
889 /**
890 * <p>
891 * Returns
892 * the first repetition of
893 * TIMING_QTY (a Group object) - creates it if necessary
894 * </p>
895 *
896 *
897 */
898 public ORU_R30_TIMING_QTY getTIMING_QTY() {
899 return getTyped("TIMING_QTY", ORU_R30_TIMING_QTY.class);
900 }
901
902
903 /**
904 * <p>
905 * Returns a specific repetition of
906 * TIMING_QTY (a Group object) - creates it if necessary
907 * </p>
908 *
909 *
910 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
911 * @throws HL7Exception if the repetition requested is more than one
912 * greater than the number of existing repetitions.
913 */
914 public ORU_R30_TIMING_QTY getTIMING_QTY(int rep) {
915 return getTyped("TIMING_QTY", rep, ORU_R30_TIMING_QTY.class);
916 }
917
918 /**
919 * <p>
920 * Returns the number of existing repetitions of TIMING_QTY
921 * </p>
922 *
923 */
924 public int getTIMING_QTYReps() {
925 return getReps("TIMING_QTY");
926 }
927
928 /**
929 * <p>
930 * Returns a non-modifiable List containing all current existing repetitions of TIMING_QTY.
931 * <p>
932 * <p>
933 * Note that unlike {@link #getTIMING_QTY()}, this method will not create any reps
934 * if none are already present, so an empty list may be returned.
935 * </p>
936 *
937 */
938 public java.util.List<ORU_R30_TIMING_QTY> getTIMING_QTYAll() throws HL7Exception {
939 return getAllAsList("TIMING_QTY", ORU_R30_TIMING_QTY.class);
940 }
941
942 /**
943 * <p>
944 * Inserts a specific repetition of TIMING_QTY (a Group object)
945 * </p>
946 *
947 *
948 * @see AbstractGroup#insertRepetition(Structure, int)
949 */
950 public void insertTIMING_QTY(ORU_R30_TIMING_QTY structure, int rep) throws HL7Exception {
951 super.insertRepetition( "TIMING_QTY", structure, rep);
952 }
953
954
955 /**
956 * <p>
957 * Inserts a specific repetition of TIMING_QTY (a Group object)
958 * </p>
959 *
960 *
961 * @see AbstractGroup#insertRepetition(Structure, int)
962 */
963 public ORU_R30_TIMING_QTY insertTIMING_QTY(int rep) throws HL7Exception {
964 return (ORU_R30_TIMING_QTY)super.insertRepetition("TIMING_QTY", rep);
965 }
966
967
968 /**
969 * <p>
970 * Removes a specific repetition of TIMING_QTY (a Group object)
971 * </p>
972 *
973 *
974 * @see AbstractGroup#removeRepetition(String, int)
975 */
976 public ORU_R30_TIMING_QTY removeTIMING_QTY(int rep) throws HL7Exception {
977 return (ORU_R30_TIMING_QTY)super.removeRepetition("TIMING_QTY", rep);
978 }
979
980
981
982
983 /**
984 * <p>
985 * Returns
986 * the first repetition of
987 * OBSERVATION (a Group object) - creates it if necessary
988 * </p>
989 *
990 *
991 */
992 public ORU_R30_OBSERVATION getOBSERVATION() {
993 return getTyped("OBSERVATION", ORU_R30_OBSERVATION.class);
994 }
995
996
997 /**
998 * <p>
999 * Returns a specific repetition of
1000 * OBSERVATION (a Group object) - creates it if necessary
1001 * </p>
1002 *
1003 *
1004 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1005 * @throws HL7Exception if the repetition requested is more than one
1006 * greater than the number of existing repetitions.
1007 */
1008 public ORU_R30_OBSERVATION getOBSERVATION(int rep) {
1009 return getTyped("OBSERVATION", rep, ORU_R30_OBSERVATION.class);
1010 }
1011
1012 /**
1013 * <p>
1014 * Returns the number of existing repetitions of OBSERVATION
1015 * </p>
1016 *
1017 */
1018 public int getOBSERVATIONReps() {
1019 return getReps("OBSERVATION");
1020 }
1021
1022 /**
1023 * <p>
1024 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION.
1025 * <p>
1026 * <p>
1027 * Note that unlike {@link #getOBSERVATION()}, this method will not create any reps
1028 * if none are already present, so an empty list may be returned.
1029 * </p>
1030 *
1031 */
1032 public java.util.List<ORU_R30_OBSERVATION> getOBSERVATIONAll() throws HL7Exception {
1033 return getAllAsList("OBSERVATION", ORU_R30_OBSERVATION.class);
1034 }
1035
1036 /**
1037 * <p>
1038 * Inserts a specific repetition of OBSERVATION (a Group object)
1039 * </p>
1040 *
1041 *
1042 * @see AbstractGroup#insertRepetition(Structure, int)
1043 */
1044 public void insertOBSERVATION(ORU_R30_OBSERVATION structure, int rep) throws HL7Exception {
1045 super.insertRepetition( "OBSERVATION", structure, rep);
1046 }
1047
1048
1049 /**
1050 * <p>
1051 * Inserts a specific repetition of OBSERVATION (a Group object)
1052 * </p>
1053 *
1054 *
1055 * @see AbstractGroup#insertRepetition(Structure, int)
1056 */
1057 public ORU_R30_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception {
1058 return (ORU_R30_OBSERVATION)super.insertRepetition("OBSERVATION", rep);
1059 }
1060
1061
1062 /**
1063 * <p>
1064 * Removes a specific repetition of OBSERVATION (a Group object)
1065 * </p>
1066 *
1067 *
1068 * @see AbstractGroup#removeRepetition(String, int)
1069 */
1070 public ORU_R30_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception {
1071 return (ORU_R30_OBSERVATION)super.removeRepetition("OBSERVATION", rep);
1072 }
1073
1074
1075
1076 }
1077