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.v23.message;
35
36 import ca.uhn.hl7v2.model.v23.group.*;
37 import ca.uhn.hl7v2.model.v23.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 RPA_I08 message structure (see chapter ?). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (Message header segment) <b> </b> </li>
50 * <li>2: MSA (Message acknowledgement segment) <b> </b> </li>
51 * <li>3: RF1 (Referral Information Segment) <b>optional </b> </li>
52 * <li>4: RPA_I08_AUTHORIZATION (a Group object) <b>optional </b> </li>
53 * <li>5: RPA_I08_PROVIDER (a Group object) <b> repeating</b> </li>
54 * <li>6: PID (Patient Identification) <b> </b> </li>
55 * <li>7: NK1 (Next of kin) <b>optional repeating</b> </li>
56 * <li>8: GT1 (Guarantor) <b>optional repeating</b> </li>
57 * <li>9: RPA_I08_INSURANCE (a Group object) <b>optional repeating</b> </li>
58 * <li>10: ACC (Accident) <b>optional </b> </li>
59 * <li>11: DG1 (Diagnosis) <b>optional repeating</b> </li>
60 * <li>12: DRG (Diagnosis Related Group) <b>optional repeating</b> </li>
61 * <li>13: AL1 (Patient allergy information) <b>optional repeating</b> </li>
62 * <li>14: RPA_I08_PROCEDURE (a Group object) <b> repeating</b> </li>
63 * <li>15: RPA_I08_OBSERVATION (a Group object) <b>optional repeating</b> </li>
64 * <li>16: RPA_I08_VISIT (a Group object) <b>optional </b> </li>
65 * </ul>
66 */
67 //@SuppressWarnings("unused")
68 public class RPA_I08 extends AbstractMessage {
69
70 /**
71 * Creates a new RPA_I08 message with DefaultModelClassFactory.
72 */
73 public RPA_I08() {
74 this(new DefaultModelClassFactory());
75 }
76
77 /**
78 * Creates a new RPA_I08 message with custom ModelClassFactory.
79 */
80 public RPA_I08(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(MSA.class, true, false);
89 this.add(RF1.class, false, false);
90 this.add(RPA_I08_AUTHORIZATION.class, false, false);
91 this.add(RPA_I08_PROVIDER.class, true, true);
92 this.add(PID.class, true, false);
93 this.add(NK1.class, false, true);
94 this.add(GT1.class, false, true);
95 this.add(RPA_I08_INSURANCE.class, false, true);
96 this.add(ACC.class, false, false);
97 this.add(DG1.class, false, true);
98 this.add(DRG.class, false, true);
99 this.add(AL1.class, false, true);
100 this.add(RPA_I08_PROCEDURE.class, true, true);
101 this.add(RPA_I08_OBSERVATION.class, false, true);
102 this.add(RPA_I08_VISIT.class, false, false);
103 } catch(HL7Exception e) {
104 log.error("Unexpected error creating RPA_I08 - this is probably a bug in the source code generator.", e);
105 }
106 }
107
108
109 /**
110 * Returns "2.3"
111 */
112 public String getVersion() {
113 return "2.3";
114 }
115
116
117
118
119 /**
120 * <p>
121 * Returns
122 * MSH (Message header segment) - 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 * MSA (Message acknowledgement segment) - creates it if necessary
139 * </p>
140 *
141 *
142 */
143 public MSA getMSA() {
144 return getTyped("MSA", MSA.class);
145 }
146
147
148
149
150
151 /**
152 * <p>
153 * Returns
154 * RF1 (Referral Information Segment) - creates it if necessary
155 * </p>
156 *
157 *
158 */
159 public RF1 getRF1() {
160 return getTyped("RF1", RF1.class);
161 }
162
163
164
165
166
167 /**
168 * <p>
169 * Returns
170 * AUTHORIZATION (a Group object) - creates it if necessary
171 * </p>
172 *
173 *
174 */
175 public RPA_I08_AUTHORIZATION getAUTHORIZATION() {
176 return getTyped("AUTHORIZATION", RPA_I08_AUTHORIZATION.class);
177 }
178
179
180
181
182
183 /**
184 * <p>
185 * Returns
186 * the first repetition of
187 * PROVIDER (a Group object) - creates it if necessary
188 * </p>
189 *
190 *
191 */
192 public RPA_I08_PROVIDER getPROVIDER() {
193 return getTyped("PROVIDER", RPA_I08_PROVIDER.class);
194 }
195
196
197 /**
198 * <p>
199 * Returns a specific repetition of
200 * PROVIDER (a Group object) - creates it if necessary
201 * </p>
202 *
203 *
204 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
205 * @throws HL7Exception if the repetition requested is more than one
206 * greater than the number of existing repetitions.
207 */
208 public RPA_I08_PROVIDER getPROVIDER(int rep) {
209 return getTyped("PROVIDER", rep, RPA_I08_PROVIDER.class);
210 }
211
212 /**
213 * <p>
214 * Returns the number of existing repetitions of PROVIDER
215 * </p>
216 *
217 */
218 public int getPROVIDERReps() {
219 return getReps("PROVIDER");
220 }
221
222 /**
223 * <p>
224 * Returns a non-modifiable List containing all current existing repetitions of PROVIDER.
225 * <p>
226 * <p>
227 * Note that unlike {@link #getPROVIDER()}, this method will not create any reps
228 * if none are already present, so an empty list may be returned.
229 * </p>
230 *
231 */
232 public java.util.List<RPA_I08_PROVIDER> getPROVIDERAll() throws HL7Exception {
233 return getAllAsList("PROVIDER", RPA_I08_PROVIDER.class);
234 }
235
236 /**
237 * <p>
238 * Inserts a specific repetition of PROVIDER (a Group object)
239 * </p>
240 *
241 *
242 * @see AbstractGroup#insertRepetition(Structure, int)
243 */
244 public void insertPROVIDER(RPA_I08_PROVIDER structure, int rep) throws HL7Exception {
245 super.insertRepetition( "PROVIDER", structure, rep);
246 }
247
248
249 /**
250 * <p>
251 * Inserts a specific repetition of PROVIDER (a Group object)
252 * </p>
253 *
254 *
255 * @see AbstractGroup#insertRepetition(Structure, int)
256 */
257 public RPA_I08_PROVIDER insertPROVIDER(int rep) throws HL7Exception {
258 return (RPA_I08_PROVIDER)super.insertRepetition("PROVIDER", rep);
259 }
260
261
262 /**
263 * <p>
264 * Removes a specific repetition of PROVIDER (a Group object)
265 * </p>
266 *
267 *
268 * @see AbstractGroup#removeRepetition(String, int)
269 */
270 public RPA_I08_PROVIDER removePROVIDER(int rep) throws HL7Exception {
271 return (RPA_I08_PROVIDER)super.removeRepetition("PROVIDER", rep);
272 }
273
274
275
276
277 /**
278 * <p>
279 * Returns
280 * PID (Patient Identification) - creates it if necessary
281 * </p>
282 *
283 *
284 */
285 public PID getPID() {
286 return getTyped("PID", PID.class);
287 }
288
289
290
291
292
293 /**
294 * <p>
295 * Returns
296 * the first repetition of
297 * NK1 (Next of kin) - creates it if necessary
298 * </p>
299 *
300 *
301 */
302 public NK1 getNK1() {
303 return getTyped("NK1", NK1.class);
304 }
305
306
307 /**
308 * <p>
309 * Returns a specific repetition of
310 * NK1 (Next of kin) - creates it if necessary
311 * </p>
312 *
313 *
314 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
315 * @throws HL7Exception if the repetition requested is more than one
316 * greater than the number of existing repetitions.
317 */
318 public NK1 getNK1(int rep) {
319 return getTyped("NK1", rep, NK1.class);
320 }
321
322 /**
323 * <p>
324 * Returns the number of existing repetitions of NK1
325 * </p>
326 *
327 */
328 public int getNK1Reps() {
329 return getReps("NK1");
330 }
331
332 /**
333 * <p>
334 * Returns a non-modifiable List containing all current existing repetitions of NK1.
335 * <p>
336 * <p>
337 * Note that unlike {@link #getNK1()}, this method will not create any reps
338 * if none are already present, so an empty list may be returned.
339 * </p>
340 *
341 */
342 public java.util.List<NK1> getNK1All() throws HL7Exception {
343 return getAllAsList("NK1", NK1.class);
344 }
345
346 /**
347 * <p>
348 * Inserts a specific repetition of NK1 (Next of kin)
349 * </p>
350 *
351 *
352 * @see AbstractGroup#insertRepetition(Structure, int)
353 */
354 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
355 super.insertRepetition( "NK1", structure, rep);
356 }
357
358
359 /**
360 * <p>
361 * Inserts a specific repetition of NK1 (Next of kin)
362 * </p>
363 *
364 *
365 * @see AbstractGroup#insertRepetition(Structure, int)
366 */
367 public NK1 insertNK1(int rep) throws HL7Exception {
368 return (NK1)super.insertRepetition("NK1", rep);
369 }
370
371
372 /**
373 * <p>
374 * Removes a specific repetition of NK1 (Next of kin)
375 * </p>
376 *
377 *
378 * @see AbstractGroup#removeRepetition(String, int)
379 */
380 public NK1 removeNK1(int rep) throws HL7Exception {
381 return (NK1)super.removeRepetition("NK1", rep);
382 }
383
384
385
386
387 /**
388 * <p>
389 * Returns
390 * the first repetition of
391 * GT1 (Guarantor) - creates it if necessary
392 * </p>
393 *
394 *
395 */
396 public GT1 getGT1() {
397 return getTyped("GT1", GT1.class);
398 }
399
400
401 /**
402 * <p>
403 * Returns a specific repetition of
404 * GT1 (Guarantor) - creates it if necessary
405 * </p>
406 *
407 *
408 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
409 * @throws HL7Exception if the repetition requested is more than one
410 * greater than the number of existing repetitions.
411 */
412 public GT1 getGT1(int rep) {
413 return getTyped("GT1", rep, GT1.class);
414 }
415
416 /**
417 * <p>
418 * Returns the number of existing repetitions of GT1
419 * </p>
420 *
421 */
422 public int getGT1Reps() {
423 return getReps("GT1");
424 }
425
426 /**
427 * <p>
428 * Returns a non-modifiable List containing all current existing repetitions of GT1.
429 * <p>
430 * <p>
431 * Note that unlike {@link #getGT1()}, this method will not create any reps
432 * if none are already present, so an empty list may be returned.
433 * </p>
434 *
435 */
436 public java.util.List<GT1> getGT1All() throws HL7Exception {
437 return getAllAsList("GT1", GT1.class);
438 }
439
440 /**
441 * <p>
442 * Inserts a specific repetition of GT1 (Guarantor)
443 * </p>
444 *
445 *
446 * @see AbstractGroup#insertRepetition(Structure, int)
447 */
448 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
449 super.insertRepetition( "GT1", structure, rep);
450 }
451
452
453 /**
454 * <p>
455 * Inserts a specific repetition of GT1 (Guarantor)
456 * </p>
457 *
458 *
459 * @see AbstractGroup#insertRepetition(Structure, int)
460 */
461 public GT1 insertGT1(int rep) throws HL7Exception {
462 return (GT1)super.insertRepetition("GT1", rep);
463 }
464
465
466 /**
467 * <p>
468 * Removes a specific repetition of GT1 (Guarantor)
469 * </p>
470 *
471 *
472 * @see AbstractGroup#removeRepetition(String, int)
473 */
474 public GT1 removeGT1(int rep) throws HL7Exception {
475 return (GT1)super.removeRepetition("GT1", rep);
476 }
477
478
479
480
481 /**
482 * <p>
483 * Returns
484 * the first repetition of
485 * INSURANCE (a Group object) - creates it if necessary
486 * </p>
487 *
488 *
489 */
490 public RPA_I08_INSURANCE getINSURANCE() {
491 return getTyped("INSURANCE", RPA_I08_INSURANCE.class);
492 }
493
494
495 /**
496 * <p>
497 * Returns a specific repetition of
498 * INSURANCE (a Group object) - creates it if necessary
499 * </p>
500 *
501 *
502 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
503 * @throws HL7Exception if the repetition requested is more than one
504 * greater than the number of existing repetitions.
505 */
506 public RPA_I08_INSURANCE getINSURANCE(int rep) {
507 return getTyped("INSURANCE", rep, RPA_I08_INSURANCE.class);
508 }
509
510 /**
511 * <p>
512 * Returns the number of existing repetitions of INSURANCE
513 * </p>
514 *
515 */
516 public int getINSURANCEReps() {
517 return getReps("INSURANCE");
518 }
519
520 /**
521 * <p>
522 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
523 * <p>
524 * <p>
525 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
526 * if none are already present, so an empty list may be returned.
527 * </p>
528 *
529 */
530 public java.util.List<RPA_I08_INSURANCE> getINSURANCEAll() throws HL7Exception {
531 return getAllAsList("INSURANCE", RPA_I08_INSURANCE.class);
532 }
533
534 /**
535 * <p>
536 * Inserts a specific repetition of INSURANCE (a Group object)
537 * </p>
538 *
539 *
540 * @see AbstractGroup#insertRepetition(Structure, int)
541 */
542 public void insertINSURANCE(RPA_I08_INSURANCE structure, int rep) throws HL7Exception {
543 super.insertRepetition( "INSURANCE", structure, rep);
544 }
545
546
547 /**
548 * <p>
549 * Inserts a specific repetition of INSURANCE (a Group object)
550 * </p>
551 *
552 *
553 * @see AbstractGroup#insertRepetition(Structure, int)
554 */
555 public RPA_I08_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
556 return (RPA_I08_INSURANCE)super.insertRepetition("INSURANCE", rep);
557 }
558
559
560 /**
561 * <p>
562 * Removes a specific repetition of INSURANCE (a Group object)
563 * </p>
564 *
565 *
566 * @see AbstractGroup#removeRepetition(String, int)
567 */
568 public RPA_I08_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
569 return (RPA_I08_INSURANCE)super.removeRepetition("INSURANCE", rep);
570 }
571
572
573
574
575 /**
576 * <p>
577 * Returns
578 * ACC (Accident) - creates it if necessary
579 * </p>
580 *
581 *
582 */
583 public ACC getACC() {
584 return getTyped("ACC", ACC.class);
585 }
586
587
588
589
590
591 /**
592 * <p>
593 * Returns
594 * the first repetition of
595 * DG1 (Diagnosis) - creates it if necessary
596 * </p>
597 *
598 *
599 */
600 public DG1 getDG1() {
601 return getTyped("DG1", DG1.class);
602 }
603
604
605 /**
606 * <p>
607 * Returns a specific repetition of
608 * DG1 (Diagnosis) - 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 DG1 getDG1(int rep) {
617 return getTyped("DG1", rep, DG1.class);
618 }
619
620 /**
621 * <p>
622 * Returns the number of existing repetitions of DG1
623 * </p>
624 *
625 */
626 public int getDG1Reps() {
627 return getReps("DG1");
628 }
629
630 /**
631 * <p>
632 * Returns a non-modifiable List containing all current existing repetitions of DG1.
633 * <p>
634 * <p>
635 * Note that unlike {@link #getDG1()}, 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<DG1> getDG1All() throws HL7Exception {
641 return getAllAsList("DG1", DG1.class);
642 }
643
644 /**
645 * <p>
646 * Inserts a specific repetition of DG1 (Diagnosis)
647 * </p>
648 *
649 *
650 * @see AbstractGroup#insertRepetition(Structure, int)
651 */
652 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
653 super.insertRepetition( "DG1", structure, rep);
654 }
655
656
657 /**
658 * <p>
659 * Inserts a specific repetition of DG1 (Diagnosis)
660 * </p>
661 *
662 *
663 * @see AbstractGroup#insertRepetition(Structure, int)
664 */
665 public DG1 insertDG1(int rep) throws HL7Exception {
666 return (DG1)super.insertRepetition("DG1", rep);
667 }
668
669
670 /**
671 * <p>
672 * Removes a specific repetition of DG1 (Diagnosis)
673 * </p>
674 *
675 *
676 * @see AbstractGroup#removeRepetition(String, int)
677 */
678 public DG1 removeDG1(int rep) throws HL7Exception {
679 return (DG1)super.removeRepetition("DG1", rep);
680 }
681
682
683
684
685 /**
686 * <p>
687 * Returns
688 * the first repetition of
689 * DRG (Diagnosis Related Group) - creates it if necessary
690 * </p>
691 *
692 *
693 */
694 public DRG getDRG() {
695 return getTyped("DRG", DRG.class);
696 }
697
698
699 /**
700 * <p>
701 * Returns a specific repetition of
702 * DRG (Diagnosis Related Group) - creates it if necessary
703 * </p>
704 *
705 *
706 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
707 * @throws HL7Exception if the repetition requested is more than one
708 * greater than the number of existing repetitions.
709 */
710 public DRG getDRG(int rep) {
711 return getTyped("DRG", rep, DRG.class);
712 }
713
714 /**
715 * <p>
716 * Returns the number of existing repetitions of DRG
717 * </p>
718 *
719 */
720 public int getDRGReps() {
721 return getReps("DRG");
722 }
723
724 /**
725 * <p>
726 * Returns a non-modifiable List containing all current existing repetitions of DRG.
727 * <p>
728 * <p>
729 * Note that unlike {@link #getDRG()}, this method will not create any reps
730 * if none are already present, so an empty list may be returned.
731 * </p>
732 *
733 */
734 public java.util.List<DRG> getDRGAll() throws HL7Exception {
735 return getAllAsList("DRG", DRG.class);
736 }
737
738 /**
739 * <p>
740 * Inserts a specific repetition of DRG (Diagnosis Related Group)
741 * </p>
742 *
743 *
744 * @see AbstractGroup#insertRepetition(Structure, int)
745 */
746 public void insertDRG(DRG structure, int rep) throws HL7Exception {
747 super.insertRepetition( "DRG", structure, rep);
748 }
749
750
751 /**
752 * <p>
753 * Inserts a specific repetition of DRG (Diagnosis Related Group)
754 * </p>
755 *
756 *
757 * @see AbstractGroup#insertRepetition(Structure, int)
758 */
759 public DRG insertDRG(int rep) throws HL7Exception {
760 return (DRG)super.insertRepetition("DRG", rep);
761 }
762
763
764 /**
765 * <p>
766 * Removes a specific repetition of DRG (Diagnosis Related Group)
767 * </p>
768 *
769 *
770 * @see AbstractGroup#removeRepetition(String, int)
771 */
772 public DRG removeDRG(int rep) throws HL7Exception {
773 return (DRG)super.removeRepetition("DRG", rep);
774 }
775
776
777
778
779 /**
780 * <p>
781 * Returns
782 * the first repetition of
783 * AL1 (Patient allergy information) - creates it if necessary
784 * </p>
785 *
786 *
787 */
788 public AL1 getAL1() {
789 return getTyped("AL1", AL1.class);
790 }
791
792
793 /**
794 * <p>
795 * Returns a specific repetition of
796 * AL1 (Patient allergy information) - creates it if necessary
797 * </p>
798 *
799 *
800 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
801 * @throws HL7Exception if the repetition requested is more than one
802 * greater than the number of existing repetitions.
803 */
804 public AL1 getAL1(int rep) {
805 return getTyped("AL1", rep, AL1.class);
806 }
807
808 /**
809 * <p>
810 * Returns the number of existing repetitions of AL1
811 * </p>
812 *
813 */
814 public int getAL1Reps() {
815 return getReps("AL1");
816 }
817
818 /**
819 * <p>
820 * Returns a non-modifiable List containing all current existing repetitions of AL1.
821 * <p>
822 * <p>
823 * Note that unlike {@link #getAL1()}, this method will not create any reps
824 * if none are already present, so an empty list may be returned.
825 * </p>
826 *
827 */
828 public java.util.List<AL1> getAL1All() throws HL7Exception {
829 return getAllAsList("AL1", AL1.class);
830 }
831
832 /**
833 * <p>
834 * Inserts a specific repetition of AL1 (Patient allergy information)
835 * </p>
836 *
837 *
838 * @see AbstractGroup#insertRepetition(Structure, int)
839 */
840 public void insertAL1(AL1 structure, int rep) throws HL7Exception {
841 super.insertRepetition( "AL1", structure, rep);
842 }
843
844
845 /**
846 * <p>
847 * Inserts a specific repetition of AL1 (Patient allergy information)
848 * </p>
849 *
850 *
851 * @see AbstractGroup#insertRepetition(Structure, int)
852 */
853 public AL1 insertAL1(int rep) throws HL7Exception {
854 return (AL1)super.insertRepetition("AL1", rep);
855 }
856
857
858 /**
859 * <p>
860 * Removes a specific repetition of AL1 (Patient allergy information)
861 * </p>
862 *
863 *
864 * @see AbstractGroup#removeRepetition(String, int)
865 */
866 public AL1 removeAL1(int rep) throws HL7Exception {
867 return (AL1)super.removeRepetition("AL1", rep);
868 }
869
870
871
872
873 /**
874 * <p>
875 * Returns
876 * the first repetition of
877 * PROCEDURE (a Group object) - creates it if necessary
878 * </p>
879 *
880 *
881 */
882 public RPA_I08_PROCEDURE getPROCEDURE() {
883 return getTyped("PROCEDURE", RPA_I08_PROCEDURE.class);
884 }
885
886
887 /**
888 * <p>
889 * Returns a specific repetition of
890 * PROCEDURE (a Group object) - creates it if necessary
891 * </p>
892 *
893 *
894 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
895 * @throws HL7Exception if the repetition requested is more than one
896 * greater than the number of existing repetitions.
897 */
898 public RPA_I08_PROCEDURE getPROCEDURE(int rep) {
899 return getTyped("PROCEDURE", rep, RPA_I08_PROCEDURE.class);
900 }
901
902 /**
903 * <p>
904 * Returns the number of existing repetitions of PROCEDURE
905 * </p>
906 *
907 */
908 public int getPROCEDUREReps() {
909 return getReps("PROCEDURE");
910 }
911
912 /**
913 * <p>
914 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE.
915 * <p>
916 * <p>
917 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps
918 * if none are already present, so an empty list may be returned.
919 * </p>
920 *
921 */
922 public java.util.List<RPA_I08_PROCEDURE> getPROCEDUREAll() throws HL7Exception {
923 return getAllAsList("PROCEDURE", RPA_I08_PROCEDURE.class);
924 }
925
926 /**
927 * <p>
928 * Inserts a specific repetition of PROCEDURE (a Group object)
929 * </p>
930 *
931 *
932 * @see AbstractGroup#insertRepetition(Structure, int)
933 */
934 public void insertPROCEDURE(RPA_I08_PROCEDURE structure, int rep) throws HL7Exception {
935 super.insertRepetition( "PROCEDURE", structure, rep);
936 }
937
938
939 /**
940 * <p>
941 * Inserts a specific repetition of PROCEDURE (a Group object)
942 * </p>
943 *
944 *
945 * @see AbstractGroup#insertRepetition(Structure, int)
946 */
947 public RPA_I08_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception {
948 return (RPA_I08_PROCEDURE)super.insertRepetition("PROCEDURE", rep);
949 }
950
951
952 /**
953 * <p>
954 * Removes a specific repetition of PROCEDURE (a Group object)
955 * </p>
956 *
957 *
958 * @see AbstractGroup#removeRepetition(String, int)
959 */
960 public RPA_I08_PROCEDURE removePROCEDURE(int rep) throws HL7Exception {
961 return (RPA_I08_PROCEDURE)super.removeRepetition("PROCEDURE", rep);
962 }
963
964
965
966
967 /**
968 * <p>
969 * Returns
970 * the first repetition of
971 * OBSERVATION (a Group object) - creates it if necessary
972 * </p>
973 *
974 *
975 */
976 public RPA_I08_OBSERVATION getOBSERVATION() {
977 return getTyped("OBSERVATION", RPA_I08_OBSERVATION.class);
978 }
979
980
981 /**
982 * <p>
983 * Returns a specific repetition of
984 * OBSERVATION (a Group object) - creates it if necessary
985 * </p>
986 *
987 *
988 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
989 * @throws HL7Exception if the repetition requested is more than one
990 * greater than the number of existing repetitions.
991 */
992 public RPA_I08_OBSERVATION getOBSERVATION(int rep) {
993 return getTyped("OBSERVATION", rep, RPA_I08_OBSERVATION.class);
994 }
995
996 /**
997 * <p>
998 * Returns the number of existing repetitions of OBSERVATION
999 * </p>
1000 *
1001 */
1002 public int getOBSERVATIONReps() {
1003 return getReps("OBSERVATION");
1004 }
1005
1006 /**
1007 * <p>
1008 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION.
1009 * <p>
1010 * <p>
1011 * Note that unlike {@link #getOBSERVATION()}, this method will not create any reps
1012 * if none are already present, so an empty list may be returned.
1013 * </p>
1014 *
1015 */
1016 public java.util.List<RPA_I08_OBSERVATION> getOBSERVATIONAll() throws HL7Exception {
1017 return getAllAsList("OBSERVATION", RPA_I08_OBSERVATION.class);
1018 }
1019
1020 /**
1021 * <p>
1022 * Inserts a specific repetition of OBSERVATION (a Group object)
1023 * </p>
1024 *
1025 *
1026 * @see AbstractGroup#insertRepetition(Structure, int)
1027 */
1028 public void insertOBSERVATION(RPA_I08_OBSERVATION structure, int rep) throws HL7Exception {
1029 super.insertRepetition( "OBSERVATION", structure, rep);
1030 }
1031
1032
1033 /**
1034 * <p>
1035 * Inserts a specific repetition of OBSERVATION (a Group object)
1036 * </p>
1037 *
1038 *
1039 * @see AbstractGroup#insertRepetition(Structure, int)
1040 */
1041 public RPA_I08_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception {
1042 return (RPA_I08_OBSERVATION)super.insertRepetition("OBSERVATION", rep);
1043 }
1044
1045
1046 /**
1047 * <p>
1048 * Removes a specific repetition of OBSERVATION (a Group object)
1049 * </p>
1050 *
1051 *
1052 * @see AbstractGroup#removeRepetition(String, int)
1053 */
1054 public RPA_I08_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception {
1055 return (RPA_I08_OBSERVATION)super.removeRepetition("OBSERVATION", rep);
1056 }
1057
1058
1059
1060
1061 /**
1062 * <p>
1063 * Returns
1064 * VISIT (a Group object) - creates it if necessary
1065 * </p>
1066 *
1067 *
1068 */
1069 public RPA_I08_VISIT getVISIT() {
1070 return getTyped("VISIT", RPA_I08_VISIT.class);
1071 }
1072
1073
1074
1075
1076 }
1077