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 RQA_I11 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: RF1 (Referral Information Segment) <b>optional </b> </li>
51 * <li>3: RQA_I11_AUTHORIZATION (a Group object) <b>optional </b> </li>
52 * <li>4: RQA_I11_PROVIDER (a Group object) <b> repeating</b> </li>
53 * <li>5: PID (Patient Identification) <b> </b> </li>
54 * <li>6: NK1 (Next of kin) <b>optional repeating</b> </li>
55 * <li>7: RQA_I11_GUARANTOR_INSURANCE (a Group object) <b>optional </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: RQA_I11_PROCEDURE (a Group object) <b>optional repeating</b> </li>
61 * <li>13: RQA_I11_RESULTS (a Group object) <b>optional repeating</b> </li>
62 * <li>14: RQA_I11_VISIT (a Group object) <b>optional </b> </li>
63 * <li>15: NTE (Notes and comments segment) <b>optional repeating</b> </li>
64 * </ul>
65 */
66 //@SuppressWarnings("unused")
67 public class RQA_I11 extends AbstractMessage {
68
69 /**
70 * Creates a new RQA_I11 message with DefaultModelClassFactory.
71 */
72 public RQA_I11() {
73 this(new DefaultModelClassFactory());
74 }
75
76 /**
77 * Creates a new RQA_I11 message with custom ModelClassFactory.
78 */
79 public RQA_I11(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(RF1.class, false, false);
88 this.add(RQA_I11_AUTHORIZATION.class, false, false);
89 this.add(RQA_I11_PROVIDER.class, true, true);
90 this.add(PID.class, true, false);
91 this.add(NK1.class, false, true);
92 this.add(RQA_I11_GUARANTOR_INSURANCE.class, false, 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(RQA_I11_PROCEDURE.class, false, true);
98 this.add(RQA_I11_RESULTS.class, false, true);
99 this.add(RQA_I11_VISIT.class, false, false);
100 this.add(NTE.class, false, true);
101 } catch(HL7Exception e) {
102 log.error("Unexpected error creating RQA_I11 - this is probably a bug in the source code generator.", e);
103 }
104 }
105
106
107 /**
108 * Returns "2.3"
109 */
110 public String getVersion() {
111 return "2.3";
112 }
113
114
115
116
117 /**
118 * <p>
119 * Returns
120 * MSH (Message header segment) - 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 * RF1 (Referral Information Segment) - creates it if necessary
137 * </p>
138 *
139 *
140 */
141 public RF1 getRF1() {
142 return getTyped("RF1", RF1.class);
143 }
144
145
146
147
148
149 /**
150 * <p>
151 * Returns
152 * AUTHORIZATION (a Group object) - creates it if necessary
153 * </p>
154 *
155 *
156 */
157 public RQA_I11_AUTHORIZATION getAUTHORIZATION() {
158 return getTyped("AUTHORIZATION", RQA_I11_AUTHORIZATION.class);
159 }
160
161
162
163
164
165 /**
166 * <p>
167 * Returns
168 * the first repetition of
169 * PROVIDER (a Group object) - creates it if necessary
170 * </p>
171 *
172 *
173 */
174 public RQA_I11_PROVIDER getPROVIDER() {
175 return getTyped("PROVIDER", RQA_I11_PROVIDER.class);
176 }
177
178
179 /**
180 * <p>
181 * Returns a specific repetition of
182 * PROVIDER (a Group object) - creates it if necessary
183 * </p>
184 *
185 *
186 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
187 * @throws HL7Exception if the repetition requested is more than one
188 * greater than the number of existing repetitions.
189 */
190 public RQA_I11_PROVIDER getPROVIDER(int rep) {
191 return getTyped("PROVIDER", rep, RQA_I11_PROVIDER.class);
192 }
193
194 /**
195 * <p>
196 * Returns the number of existing repetitions of PROVIDER
197 * </p>
198 *
199 */
200 public int getPROVIDERReps() {
201 return getReps("PROVIDER");
202 }
203
204 /**
205 * <p>
206 * Returns a non-modifiable List containing all current existing repetitions of PROVIDER.
207 * <p>
208 * <p>
209 * Note that unlike {@link #getPROVIDER()}, this method will not create any reps
210 * if none are already present, so an empty list may be returned.
211 * </p>
212 *
213 */
214 public java.util.List<RQA_I11_PROVIDER> getPROVIDERAll() throws HL7Exception {
215 return getAllAsList("PROVIDER", RQA_I11_PROVIDER.class);
216 }
217
218 /**
219 * <p>
220 * Inserts a specific repetition of PROVIDER (a Group object)
221 * </p>
222 *
223 *
224 * @see AbstractGroup#insertRepetition(Structure, int)
225 */
226 public void insertPROVIDER(RQA_I11_PROVIDER structure, int rep) throws HL7Exception {
227 super.insertRepetition( "PROVIDER", structure, rep);
228 }
229
230
231 /**
232 * <p>
233 * Inserts a specific repetition of PROVIDER (a Group object)
234 * </p>
235 *
236 *
237 * @see AbstractGroup#insertRepetition(Structure, int)
238 */
239 public RQA_I11_PROVIDER insertPROVIDER(int rep) throws HL7Exception {
240 return (RQA_I11_PROVIDER)super.insertRepetition("PROVIDER", rep);
241 }
242
243
244 /**
245 * <p>
246 * Removes a specific repetition of PROVIDER (a Group object)
247 * </p>
248 *
249 *
250 * @see AbstractGroup#removeRepetition(String, int)
251 */
252 public RQA_I11_PROVIDER removePROVIDER(int rep) throws HL7Exception {
253 return (RQA_I11_PROVIDER)super.removeRepetition("PROVIDER", rep);
254 }
255
256
257
258
259 /**
260 * <p>
261 * Returns
262 * PID (Patient Identification) - creates it if necessary
263 * </p>
264 *
265 *
266 */
267 public PID getPID() {
268 return getTyped("PID", PID.class);
269 }
270
271
272
273
274
275 /**
276 * <p>
277 * Returns
278 * the first repetition of
279 * NK1 (Next of kin) - creates it if necessary
280 * </p>
281 *
282 *
283 */
284 public NK1 getNK1() {
285 return getTyped("NK1", NK1.class);
286 }
287
288
289 /**
290 * <p>
291 * Returns a specific repetition of
292 * NK1 (Next of kin) - 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 NK1 getNK1(int rep) {
301 return getTyped("NK1", rep, NK1.class);
302 }
303
304 /**
305 * <p>
306 * Returns the number of existing repetitions of NK1
307 * </p>
308 *
309 */
310 public int getNK1Reps() {
311 return getReps("NK1");
312 }
313
314 /**
315 * <p>
316 * Returns a non-modifiable List containing all current existing repetitions of NK1.
317 * <p>
318 * <p>
319 * Note that unlike {@link #getNK1()}, 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<NK1> getNK1All() throws HL7Exception {
325 return getAllAsList("NK1", NK1.class);
326 }
327
328 /**
329 * <p>
330 * Inserts a specific repetition of NK1 (Next of kin)
331 * </p>
332 *
333 *
334 * @see AbstractGroup#insertRepetition(Structure, int)
335 */
336 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
337 super.insertRepetition( "NK1", structure, rep);
338 }
339
340
341 /**
342 * <p>
343 * Inserts a specific repetition of NK1 (Next of kin)
344 * </p>
345 *
346 *
347 * @see AbstractGroup#insertRepetition(Structure, int)
348 */
349 public NK1 insertNK1(int rep) throws HL7Exception {
350 return (NK1)super.insertRepetition("NK1", rep);
351 }
352
353
354 /**
355 * <p>
356 * Removes a specific repetition of NK1 (Next of kin)
357 * </p>
358 *
359 *
360 * @see AbstractGroup#removeRepetition(String, int)
361 */
362 public NK1 removeNK1(int rep) throws HL7Exception {
363 return (NK1)super.removeRepetition("NK1", rep);
364 }
365
366
367
368
369 /**
370 * <p>
371 * Returns
372 * GUARANTOR_INSURANCE (a Group object) - creates it if necessary
373 * </p>
374 *
375 *
376 */
377 public RQA_I11_GUARANTOR_INSURANCE getGUARANTOR_INSURANCE() {
378 return getTyped("GUARANTOR_INSURANCE", RQA_I11_GUARANTOR_INSURANCE.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 RQA_I11_PROCEDURE getPROCEDURE() {
693 return getTyped("PROCEDURE", RQA_I11_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 RQA_I11_PROCEDURE getPROCEDURE(int rep) {
709 return getTyped("PROCEDURE", rep, RQA_I11_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<RQA_I11_PROCEDURE> getPROCEDUREAll() throws HL7Exception {
733 return getAllAsList("PROCEDURE", RQA_I11_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(RQA_I11_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 RQA_I11_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception {
758 return (RQA_I11_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 RQA_I11_PROCEDURE removePROCEDURE(int rep) throws HL7Exception {
771 return (RQA_I11_PROCEDURE)super.removeRepetition("PROCEDURE", rep);
772 }
773
774
775
776
777 /**
778 * <p>
779 * Returns
780 * the first repetition of
781 * RESULTS (a Group object) - creates it if necessary
782 * </p>
783 *
784 *
785 */
786 public RQA_I11_RESULTS getRESULTS() {
787 return getTyped("RESULTS", RQA_I11_RESULTS.class);
788 }
789
790
791 /**
792 * <p>
793 * Returns a specific repetition of
794 * RESULTS (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 RQA_I11_RESULTS getRESULTS(int rep) {
803 return getTyped("RESULTS", rep, RQA_I11_RESULTS.class);
804 }
805
806 /**
807 * <p>
808 * Returns the number of existing repetitions of RESULTS
809 * </p>
810 *
811 */
812 public int getRESULTSReps() {
813 return getReps("RESULTS");
814 }
815
816 /**
817 * <p>
818 * Returns a non-modifiable List containing all current existing repetitions of RESULTS.
819 * <p>
820 * <p>
821 * Note that unlike {@link #getRESULTS()}, 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<RQA_I11_RESULTS> getRESULTSAll() throws HL7Exception {
827 return getAllAsList("RESULTS", RQA_I11_RESULTS.class);
828 }
829
830 /**
831 * <p>
832 * Inserts a specific repetition of RESULTS (a Group object)
833 * </p>
834 *
835 *
836 * @see AbstractGroup#insertRepetition(Structure, int)
837 */
838 public void insertRESULTS(RQA_I11_RESULTS structure, int rep) throws HL7Exception {
839 super.insertRepetition( "RESULTS", structure, rep);
840 }
841
842
843 /**
844 * <p>
845 * Inserts a specific repetition of RESULTS (a Group object)
846 * </p>
847 *
848 *
849 * @see AbstractGroup#insertRepetition(Structure, int)
850 */
851 public RQA_I11_RESULTS insertRESULTS(int rep) throws HL7Exception {
852 return (RQA_I11_RESULTS)super.insertRepetition("RESULTS", rep);
853 }
854
855
856 /**
857 * <p>
858 * Removes a specific repetition of RESULTS (a Group object)
859 * </p>
860 *
861 *
862 * @see AbstractGroup#removeRepetition(String, int)
863 */
864 public RQA_I11_RESULTS removeRESULTS(int rep) throws HL7Exception {
865 return (RQA_I11_RESULTS)super.removeRepetition("RESULTS", rep);
866 }
867
868
869
870
871 /**
872 * <p>
873 * Returns
874 * VISIT (a Group object) - creates it if necessary
875 * </p>
876 *
877 *
878 */
879 public RQA_I11_VISIT getVISIT() {
880 return getTyped("VISIT", RQA_I11_VISIT.class);
881 }
882
883
884
885
886
887 /**
888 * <p>
889 * Returns
890 * the first repetition of
891 * NTE (Notes and comments segment) - 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 segment) - 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 segment)
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 segment)
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 segment)
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