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