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.v27.message;
35
36 import ca.uhn.hl7v2.model.v27.group.*;
37 import ca.uhn.hl7v2.model.v27.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: ORU_R30_PATIENT_OBSERVATION (a Group object) <b>optional repeating</b> </li>
56 * <li>8: ORU_R30_VISIT (a Group object) <b>optional </b> </li>
57 * <li>9: ORC (Common Order) <b> </b> </li>
58 * <li>10: OBR (Observation Request) <b> </b> </li>
59 * <li>11: NTE (Notes and Comments) <b>optional repeating</b> </li>
60 * <li>12: PRT (Participation Information) <b>optional repeating</b> </li>
61 * <li>13: ORU_R30_TIMING_QTY (a Group object) <b>optional repeating</b> </li>
62 * <li>14: ORU_R30_OBSERVATION (a Group object) <b> repeating</b> </li>
63 * </ul>
64 */
65 //@SuppressWarnings("unused")
66 public class ORU_R30 extends AbstractMessage {
67
68 /**
69 * Creates a new ORU_R30 message with DefaultModelClassFactory.
70 */
71 public ORU_R30() {
72 this(new DefaultModelClassFactory());
73 }
74
75 /**
76 * Creates a new ORU_R30 message with custom ModelClassFactory.
77 */
78 public ORU_R30(ModelClassFactory factory) {
79 super(factory);
80 init(factory);
81 }
82
83 private void init(ModelClassFactory factory) {
84 try {
85 this.add(MSH.class, true, false);
86 this.add(SFT.class, false, true);
87 this.add(UAC.class, false, false);
88 this.add(PID.class, true, false);
89 this.add(PD1.class, false, false);
90 this.add(PRT.class, false, true);
91 this.add(ORU_R30_PATIENT_OBSERVATION.class, false, true);
92 this.add(ORU_R30_VISIT.class, false, false);
93 this.add(ORC.class, true, false);
94 this.add(OBR.class, true, false);
95 this.add(NTE.class, false, true);
96 this.add(PRT.class, false, true);
97 this.add(ORU_R30_TIMING_QTY.class, false, true);
98 this.add(ORU_R30_OBSERVATION.class, true, true);
99 } catch(HL7Exception e) {
100 log.error("Unexpected error creating ORU_R30 - this is probably a bug in the source code generator.", e);
101 }
102 }
103
104
105 /**
106 * Returns "2.7"
107 */
108 public String getVersion() {
109 return "2.7";
110 }
111
112
113
114
115 /**
116 * <p>
117 * Returns
118 * MSH (Message Header) - creates it if necessary
119 * </p>
120 *
121 *
122 */
123 public MSH getMSH() {
124 return getTyped("MSH", MSH.class);
125 }
126
127
128
129
130
131 /**
132 * <p>
133 * Returns
134 * the first repetition of
135 * SFT (Software Segment) - creates it if necessary
136 * </p>
137 *
138 *
139 */
140 public SFT getSFT() {
141 return getTyped("SFT", SFT.class);
142 }
143
144
145 /**
146 * <p>
147 * Returns a specific repetition of
148 * SFT (Software Segment) - creates it if necessary
149 * </p>
150 *
151 *
152 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
153 * @throws HL7Exception if the repetition requested is more than one
154 * greater than the number of existing repetitions.
155 */
156 public SFT getSFT(int rep) {
157 return getTyped("SFT", rep, SFT.class);
158 }
159
160 /**
161 * <p>
162 * Returns the number of existing repetitions of SFT
163 * </p>
164 *
165 */
166 public int getSFTReps() {
167 return getReps("SFT");
168 }
169
170 /**
171 * <p>
172 * Returns a non-modifiable List containing all current existing repetitions of SFT.
173 * <p>
174 * <p>
175 * Note that unlike {@link #getSFT()}, this method will not create any reps
176 * if none are already present, so an empty list may be returned.
177 * </p>
178 *
179 */
180 public java.util.List<SFT> getSFTAll() throws HL7Exception {
181 return getAllAsList("SFT", SFT.class);
182 }
183
184 /**
185 * <p>
186 * Inserts a specific repetition of SFT (Software Segment)
187 * </p>
188 *
189 *
190 * @see AbstractGroup#insertRepetition(Structure, int)
191 */
192 public void insertSFT(SFT structure, int rep) throws HL7Exception {
193 super.insertRepetition( "SFT", structure, rep);
194 }
195
196
197 /**
198 * <p>
199 * Inserts a specific repetition of SFT (Software Segment)
200 * </p>
201 *
202 *
203 * @see AbstractGroup#insertRepetition(Structure, int)
204 */
205 public SFT insertSFT(int rep) throws HL7Exception {
206 return (SFT)super.insertRepetition("SFT", rep);
207 }
208
209
210 /**
211 * <p>
212 * Removes a specific repetition of SFT (Software Segment)
213 * </p>
214 *
215 *
216 * @see AbstractGroup#removeRepetition(String, int)
217 */
218 public SFT removeSFT(int rep) throws HL7Exception {
219 return (SFT)super.removeRepetition("SFT", rep);
220 }
221
222
223
224
225 /**
226 * <p>
227 * Returns
228 * UAC (User Authentication Credential Segment) - creates it if necessary
229 * </p>
230 *
231 *
232 */
233 public UAC getUAC() {
234 return getTyped("UAC", UAC.class);
235 }
236
237
238
239
240
241 /**
242 * <p>
243 * Returns
244 * PID (Patient Identification) - creates it if necessary
245 * </p>
246 *
247 *
248 */
249 public PID getPID() {
250 return getTyped("PID", PID.class);
251 }
252
253
254
255
256
257 /**
258 * <p>
259 * Returns
260 * PD1 (Patient Additional Demographic) - creates it if necessary
261 * </p>
262 *
263 *
264 */
265 public PD1 getPD1() {
266 return getTyped("PD1", PD1.class);
267 }
268
269
270
271
272
273 /**
274 * <p>
275 * Returns
276 * the first repetition of
277 * PRT (Participation Information) - creates it if necessary
278 * </p>
279 *
280 *
281 */
282 public PRT getPRT() {
283 return getTyped("PRT", PRT.class);
284 }
285
286
287 /**
288 * <p>
289 * Returns a specific repetition of
290 * PRT (Participation Information) - creates it if necessary
291 * </p>
292 *
293 *
294 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
295 * @throws HL7Exception if the repetition requested is more than one
296 * greater than the number of existing repetitions.
297 */
298 public PRT getPRT(int rep) {
299 return getTyped("PRT", rep, PRT.class);
300 }
301
302 /**
303 * <p>
304 * Returns the number of existing repetitions of PRT
305 * </p>
306 *
307 */
308 public int getPRTReps() {
309 return getReps("PRT");
310 }
311
312 /**
313 * <p>
314 * Returns a non-modifiable List containing all current existing repetitions of PRT.
315 * <p>
316 * <p>
317 * Note that unlike {@link #getPRT()}, this method will not create any reps
318 * if none are already present, so an empty list may be returned.
319 * </p>
320 *
321 */
322 public java.util.List<PRT> getPRTAll() throws HL7Exception {
323 return getAllAsList("PRT", PRT.class);
324 }
325
326 /**
327 * <p>
328 * Inserts a specific repetition of PRT (Participation Information)
329 * </p>
330 *
331 *
332 * @see AbstractGroup#insertRepetition(Structure, int)
333 */
334 public void insertPRT(PRT structure, int rep) throws HL7Exception {
335 super.insertRepetition( "PRT", structure, rep);
336 }
337
338
339 /**
340 * <p>
341 * Inserts a specific repetition of PRT (Participation Information)
342 * </p>
343 *
344 *
345 * @see AbstractGroup#insertRepetition(Structure, int)
346 */
347 public PRT insertPRT(int rep) throws HL7Exception {
348 return (PRT)super.insertRepetition("PRT", rep);
349 }
350
351
352 /**
353 * <p>
354 * Removes a specific repetition of PRT (Participation Information)
355 * </p>
356 *
357 *
358 * @see AbstractGroup#removeRepetition(String, int)
359 */
360 public PRT removePRT(int rep) throws HL7Exception {
361 return (PRT)super.removeRepetition("PRT", rep);
362 }
363
364
365
366
367 /**
368 * <p>
369 * Returns
370 * the first repetition of
371 * PATIENT_OBSERVATION (a Group object) - creates it if necessary
372 * </p>
373 *
374 *
375 */
376 public ORU_R30_PATIENT_OBSERVATION getPATIENT_OBSERVATION() {
377 return getTyped("PATIENT_OBSERVATION", ORU_R30_PATIENT_OBSERVATION.class);
378 }
379
380
381 /**
382 * <p>
383 * Returns a specific repetition of
384 * PATIENT_OBSERVATION (a Group object) - creates it if necessary
385 * </p>
386 *
387 *
388 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
389 * @throws HL7Exception if the repetition requested is more than one
390 * greater than the number of existing repetitions.
391 */
392 public ORU_R30_PATIENT_OBSERVATION getPATIENT_OBSERVATION(int rep) {
393 return getTyped("PATIENT_OBSERVATION", rep, ORU_R30_PATIENT_OBSERVATION.class);
394 }
395
396 /**
397 * <p>
398 * Returns the number of existing repetitions of PATIENT_OBSERVATION
399 * </p>
400 *
401 */
402 public int getPATIENT_OBSERVATIONReps() {
403 return getReps("PATIENT_OBSERVATION");
404 }
405
406 /**
407 * <p>
408 * Returns a non-modifiable List containing all current existing repetitions of PATIENT_OBSERVATION.
409 * <p>
410 * <p>
411 * Note that unlike {@link #getPATIENT_OBSERVATION()}, this method will not create any reps
412 * if none are already present, so an empty list may be returned.
413 * </p>
414 *
415 */
416 public java.util.List<ORU_R30_PATIENT_OBSERVATION> getPATIENT_OBSERVATIONAll() throws HL7Exception {
417 return getAllAsList("PATIENT_OBSERVATION", ORU_R30_PATIENT_OBSERVATION.class);
418 }
419
420 /**
421 * <p>
422 * Inserts a specific repetition of PATIENT_OBSERVATION (a Group object)
423 * </p>
424 *
425 *
426 * @see AbstractGroup#insertRepetition(Structure, int)
427 */
428 public void insertPATIENT_OBSERVATION(ORU_R30_PATIENT_OBSERVATION structure, int rep) throws HL7Exception {
429 super.insertRepetition( "PATIENT_OBSERVATION", structure, rep);
430 }
431
432
433 /**
434 * <p>
435 * Inserts a specific repetition of PATIENT_OBSERVATION (a Group object)
436 * </p>
437 *
438 *
439 * @see AbstractGroup#insertRepetition(Structure, int)
440 */
441 public ORU_R30_PATIENT_OBSERVATION insertPATIENT_OBSERVATION(int rep) throws HL7Exception {
442 return (ORU_R30_PATIENT_OBSERVATION)super.insertRepetition("PATIENT_OBSERVATION", rep);
443 }
444
445
446 /**
447 * <p>
448 * Removes a specific repetition of PATIENT_OBSERVATION (a Group object)
449 * </p>
450 *
451 *
452 * @see AbstractGroup#removeRepetition(String, int)
453 */
454 public ORU_R30_PATIENT_OBSERVATION removePATIENT_OBSERVATION(int rep) throws HL7Exception {
455 return (ORU_R30_PATIENT_OBSERVATION)super.removeRepetition("PATIENT_OBSERVATION", rep);
456 }
457
458
459
460
461 /**
462 * <p>
463 * Returns
464 * VISIT (a Group object) - creates it if necessary
465 * </p>
466 *
467 *
468 */
469 public ORU_R30_VISIT getVISIT() {
470 return getTyped("VISIT", ORU_R30_VISIT.class);
471 }
472
473
474
475
476
477 /**
478 * <p>
479 * Returns
480 * ORC (Common Order) - creates it if necessary
481 * </p>
482 *
483 *
484 */
485 public ORC getORC() {
486 return getTyped("ORC", ORC.class);
487 }
488
489
490
491
492
493 /**
494 * <p>
495 * Returns
496 * OBR (Observation Request) - creates it if necessary
497 * </p>
498 *
499 *
500 */
501 public OBR getOBR() {
502 return getTyped("OBR", OBR.class);
503 }
504
505
506
507
508
509 /**
510 * <p>
511 * Returns
512 * the first repetition of
513 * NTE (Notes and Comments) - creates it if necessary
514 * </p>
515 *
516 *
517 */
518 public NTE getNTE() {
519 return getTyped("NTE", NTE.class);
520 }
521
522
523 /**
524 * <p>
525 * Returns a specific repetition of
526 * NTE (Notes and Comments) - creates it if necessary
527 * </p>
528 *
529 *
530 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
531 * @throws HL7Exception if the repetition requested is more than one
532 * greater than the number of existing repetitions.
533 */
534 public NTE getNTE(int rep) {
535 return getTyped("NTE", rep, NTE.class);
536 }
537
538 /**
539 * <p>
540 * Returns the number of existing repetitions of NTE
541 * </p>
542 *
543 */
544 public int getNTEReps() {
545 return getReps("NTE");
546 }
547
548 /**
549 * <p>
550 * Returns a non-modifiable List containing all current existing repetitions of NTE.
551 * <p>
552 * <p>
553 * Note that unlike {@link #getNTE()}, this method will not create any reps
554 * if none are already present, so an empty list may be returned.
555 * </p>
556 *
557 */
558 public java.util.List<NTE> getNTEAll() throws HL7Exception {
559 return getAllAsList("NTE", NTE.class);
560 }
561
562 /**
563 * <p>
564 * Inserts a specific repetition of NTE (Notes and Comments)
565 * </p>
566 *
567 *
568 * @see AbstractGroup#insertRepetition(Structure, int)
569 */
570 public void insertNTE(NTE structure, int rep) throws HL7Exception {
571 super.insertRepetition( "NTE", structure, rep);
572 }
573
574
575 /**
576 * <p>
577 * Inserts a specific repetition of NTE (Notes and Comments)
578 * </p>
579 *
580 *
581 * @see AbstractGroup#insertRepetition(Structure, int)
582 */
583 public NTE insertNTE(int rep) throws HL7Exception {
584 return (NTE)super.insertRepetition("NTE", rep);
585 }
586
587
588 /**
589 * <p>
590 * Removes a specific repetition of NTE (Notes and Comments)
591 * </p>
592 *
593 *
594 * @see AbstractGroup#removeRepetition(String, int)
595 */
596 public NTE removeNTE(int rep) throws HL7Exception {
597 return (NTE)super.removeRepetition("NTE", rep);
598 }
599
600
601
602
603 /**
604 * <p>
605 * Returns
606 * the first repetition of
607 * PRT2 (Participation Information) - creates it if necessary
608 * </p>
609 *
610 *
611 */
612 public PRT getPRT2() {
613 return getTyped("PRT2", PRT.class);
614 }
615
616
617 /**
618 * <p>
619 * Returns a specific repetition of
620 * PRT2 (Participation Information) - creates it if necessary
621 * </p>
622 *
623 *
624 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
625 * @throws HL7Exception if the repetition requested is more than one
626 * greater than the number of existing repetitions.
627 */
628 public PRT getPRT2(int rep) {
629 return getTyped("PRT2", rep, PRT.class);
630 }
631
632 /**
633 * <p>
634 * Returns the number of existing repetitions of PRT2
635 * </p>
636 *
637 */
638 public int getPRT2Reps() {
639 return getReps("PRT2");
640 }
641
642 /**
643 * <p>
644 * Returns a non-modifiable List containing all current existing repetitions of PRT2.
645 * <p>
646 * <p>
647 * Note that unlike {@link #getPRT2()}, this method will not create any reps
648 * if none are already present, so an empty list may be returned.
649 * </p>
650 *
651 */
652 public java.util.List<PRT> getPRT2All() throws HL7Exception {
653 return getAllAsList("PRT2", PRT.class);
654 }
655
656 /**
657 * <p>
658 * Inserts a specific repetition of PRT2 (Participation Information)
659 * </p>
660 *
661 *
662 * @see AbstractGroup#insertRepetition(Structure, int)
663 */
664 public void insertPRT2(PRT structure, int rep) throws HL7Exception {
665 super.insertRepetition( "PRT2", structure, rep);
666 }
667
668
669 /**
670 * <p>
671 * Inserts a specific repetition of PRT2 (Participation Information)
672 * </p>
673 *
674 *
675 * @see AbstractGroup#insertRepetition(Structure, int)
676 */
677 public PRT insertPRT2(int rep) throws HL7Exception {
678 return (PRT)super.insertRepetition("PRT2", rep);
679 }
680
681
682 /**
683 * <p>
684 * Removes a specific repetition of PRT2 (Participation Information)
685 * </p>
686 *
687 *
688 * @see AbstractGroup#removeRepetition(String, int)
689 */
690 public PRT removePRT2(int rep) throws HL7Exception {
691 return (PRT)super.removeRepetition("PRT2", rep);
692 }
693
694
695
696
697 /**
698 * <p>
699 * Returns
700 * the first repetition of
701 * TIMING_QTY (a Group object) - creates it if necessary
702 * </p>
703 *
704 *
705 */
706 public ORU_R30_TIMING_QTY getTIMING_QTY() {
707 return getTyped("TIMING_QTY", ORU_R30_TIMING_QTY.class);
708 }
709
710
711 /**
712 * <p>
713 * Returns a specific repetition of
714 * TIMING_QTY (a Group object) - creates it if necessary
715 * </p>
716 *
717 *
718 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
719 * @throws HL7Exception if the repetition requested is more than one
720 * greater than the number of existing repetitions.
721 */
722 public ORU_R30_TIMING_QTY getTIMING_QTY(int rep) {
723 return getTyped("TIMING_QTY", rep, ORU_R30_TIMING_QTY.class);
724 }
725
726 /**
727 * <p>
728 * Returns the number of existing repetitions of TIMING_QTY
729 * </p>
730 *
731 */
732 public int getTIMING_QTYReps() {
733 return getReps("TIMING_QTY");
734 }
735
736 /**
737 * <p>
738 * Returns a non-modifiable List containing all current existing repetitions of TIMING_QTY.
739 * <p>
740 * <p>
741 * Note that unlike {@link #getTIMING_QTY()}, this method will not create any reps
742 * if none are already present, so an empty list may be returned.
743 * </p>
744 *
745 */
746 public java.util.List<ORU_R30_TIMING_QTY> getTIMING_QTYAll() throws HL7Exception {
747 return getAllAsList("TIMING_QTY", ORU_R30_TIMING_QTY.class);
748 }
749
750 /**
751 * <p>
752 * Inserts a specific repetition of TIMING_QTY (a Group object)
753 * </p>
754 *
755 *
756 * @see AbstractGroup#insertRepetition(Structure, int)
757 */
758 public void insertTIMING_QTY(ORU_R30_TIMING_QTY structure, int rep) throws HL7Exception {
759 super.insertRepetition( "TIMING_QTY", structure, rep);
760 }
761
762
763 /**
764 * <p>
765 * Inserts a specific repetition of TIMING_QTY (a Group object)
766 * </p>
767 *
768 *
769 * @see AbstractGroup#insertRepetition(Structure, int)
770 */
771 public ORU_R30_TIMING_QTY insertTIMING_QTY(int rep) throws HL7Exception {
772 return (ORU_R30_TIMING_QTY)super.insertRepetition("TIMING_QTY", rep);
773 }
774
775
776 /**
777 * <p>
778 * Removes a specific repetition of TIMING_QTY (a Group object)
779 * </p>
780 *
781 *
782 * @see AbstractGroup#removeRepetition(String, int)
783 */
784 public ORU_R30_TIMING_QTY removeTIMING_QTY(int rep) throws HL7Exception {
785 return (ORU_R30_TIMING_QTY)super.removeRepetition("TIMING_QTY", rep);
786 }
787
788
789
790
791 /**
792 * <p>
793 * Returns
794 * the first repetition of
795 * OBSERVATION (a Group object) - creates it if necessary
796 * </p>
797 *
798 *
799 */
800 public ORU_R30_OBSERVATION getOBSERVATION() {
801 return getTyped("OBSERVATION", ORU_R30_OBSERVATION.class);
802 }
803
804
805 /**
806 * <p>
807 * Returns a specific repetition of
808 * OBSERVATION (a Group object) - creates it if necessary
809 * </p>
810 *
811 *
812 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
813 * @throws HL7Exception if the repetition requested is more than one
814 * greater than the number of existing repetitions.
815 */
816 public ORU_R30_OBSERVATION getOBSERVATION(int rep) {
817 return getTyped("OBSERVATION", rep, ORU_R30_OBSERVATION.class);
818 }
819
820 /**
821 * <p>
822 * Returns the number of existing repetitions of OBSERVATION
823 * </p>
824 *
825 */
826 public int getOBSERVATIONReps() {
827 return getReps("OBSERVATION");
828 }
829
830 /**
831 * <p>
832 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION.
833 * <p>
834 * <p>
835 * Note that unlike {@link #getOBSERVATION()}, this method will not create any reps
836 * if none are already present, so an empty list may be returned.
837 * </p>
838 *
839 */
840 public java.util.List<ORU_R30_OBSERVATION> getOBSERVATIONAll() throws HL7Exception {
841 return getAllAsList("OBSERVATION", ORU_R30_OBSERVATION.class);
842 }
843
844 /**
845 * <p>
846 * Inserts a specific repetition of OBSERVATION (a Group object)
847 * </p>
848 *
849 *
850 * @see AbstractGroup#insertRepetition(Structure, int)
851 */
852 public void insertOBSERVATION(ORU_R30_OBSERVATION structure, int rep) throws HL7Exception {
853 super.insertRepetition( "OBSERVATION", structure, rep);
854 }
855
856
857 /**
858 * <p>
859 * Inserts a specific repetition of OBSERVATION (a Group object)
860 * </p>
861 *
862 *
863 * @see AbstractGroup#insertRepetition(Structure, int)
864 */
865 public ORU_R30_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception {
866 return (ORU_R30_OBSERVATION)super.insertRepetition("OBSERVATION", rep);
867 }
868
869
870 /**
871 * <p>
872 * Removes a specific repetition of OBSERVATION (a Group object)
873 * </p>
874 *
875 *
876 * @see AbstractGroup#removeRepetition(String, int)
877 */
878 public ORU_R30_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception {
879 return (ORU_R30_OBSERVATION)super.removeRepetition("OBSERVATION", rep);
880 }
881
882
883
884 }
885