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