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.v24.message;
35
36 import ca.uhn.hl7v2.model.v24.group.*;
37 import ca.uhn.hl7v2.model.v24.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 DFT_P11 message structure (see chapter 6.4.3). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (Message Header) <b> </b> </li>
50 * <li>2: EVN (Event Type) <b> </b> </li>
51 * <li>3: PID (Patient identification) <b> </b> </li>
52 * <li>4: PD1 (patient additional demographic) <b>optional </b> </li>
53 * <li>5: ROL (Role) <b>optional repeating</b> </li>
54 * <li>6: PV1 (Patient visit) <b>optional </b> </li>
55 * <li>7: PV2 (Patient visit - additional information) <b>optional </b> </li>
56 * <li>8: ROL (Role) <b>optional repeating</b> </li>
57 * <li>9: DB1 (Disability) <b>optional repeating</b> </li>
58 * <li>10: DFT_P11_COMMON_ORDER (a Group object) <b>optional repeating</b> </li>
59 * <li>11: DG1 (Diagnosis) <b>optional repeating</b> </li>
60 * <li>12: DRG (Diagnosis Related Group) <b>optional </b> </li>
61 * <li>13: GT1 (Guarantor) <b>optional repeating</b> </li>
62 * <li>14: DFT_P11_INSURANCE (a Group object) <b>optional repeating</b> </li>
63 * <li>15: ACC (Accident) <b>optional </b> </li>
64 * <li>16: DFT_P11_FINANCIAL (a Group object) <b> repeating</b> </li>
65 * </ul>
66 */
67 //@SuppressWarnings("unused")
68 public class DFT_P11 extends AbstractMessage {
69
70 /**
71 * Creates a new DFT_P11 message with DefaultModelClassFactory.
72 */
73 public DFT_P11() {
74 this(new DefaultModelClassFactory());
75 }
76
77 /**
78 * Creates a new DFT_P11 message with custom ModelClassFactory.
79 */
80 public DFT_P11(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(EVN.class, true, false);
89 this.add(PID.class, true, false);
90 this.add(PD1.class, false, false);
91 this.add(ROL.class, false, true);
92 this.add(PV1.class, false, false);
93 this.add(PV2.class, false, false);
94 this.add(ROL.class, false, true);
95 this.add(DB1.class, false, true);
96 this.add(DFT_P11_COMMON_ORDER.class, false, true);
97 this.add(DG1.class, false, true);
98 this.add(DRG.class, false, false);
99 this.add(GT1.class, false, true);
100 this.add(DFT_P11_INSURANCE.class, false, true);
101 this.add(ACC.class, false, false);
102 this.add(DFT_P11_FINANCIAL.class, true, true);
103 } catch(HL7Exception e) {
104 log.error("Unexpected error creating DFT_P11 - this is probably a bug in the source code generator.", e);
105 }
106 }
107
108
109 /**
110 * Returns "2.4"
111 */
112 public String getVersion() {
113 return "2.4";
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 * EVN (Event Type) - creates it if necessary
139 * </p>
140 *
141 *
142 */
143 public EVN getEVN() {
144 return getTyped("EVN", EVN.class);
145 }
146
147
148
149
150
151 /**
152 * <p>
153 * Returns
154 * PID (Patient identification) - creates it if necessary
155 * </p>
156 *
157 *
158 */
159 public PID getPID() {
160 return getTyped("PID", PID.class);
161 }
162
163
164
165
166
167 /**
168 * <p>
169 * Returns
170 * PD1 (patient additional demographic) - creates it if necessary
171 * </p>
172 *
173 *
174 */
175 public PD1 getPD1() {
176 return getTyped("PD1", PD1.class);
177 }
178
179
180
181
182
183 /**
184 * <p>
185 * Returns
186 * the first repetition of
187 * ROL (Role) - creates it if necessary
188 * </p>
189 *
190 *
191 */
192 public ROL getROL() {
193 return getTyped("ROL", ROL.class);
194 }
195
196
197 /**
198 * <p>
199 * Returns a specific repetition of
200 * ROL (Role) - 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 ROL getROL(int rep) {
209 return getTyped("ROL", rep, ROL.class);
210 }
211
212 /**
213 * <p>
214 * Returns the number of existing repetitions of ROL
215 * </p>
216 *
217 */
218 public int getROLReps() {
219 return getReps("ROL");
220 }
221
222 /**
223 * <p>
224 * Returns a non-modifiable List containing all current existing repetitions of ROL.
225 * <p>
226 * <p>
227 * Note that unlike {@link #getROL()}, 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<ROL> getROLAll() throws HL7Exception {
233 return getAllAsList("ROL", ROL.class);
234 }
235
236 /**
237 * <p>
238 * Inserts a specific repetition of ROL (Role)
239 * </p>
240 *
241 *
242 * @see AbstractGroup#insertRepetition(Structure, int)
243 */
244 public void insertROL(ROL structure, int rep) throws HL7Exception {
245 super.insertRepetition( "ROL", structure, rep);
246 }
247
248
249 /**
250 * <p>
251 * Inserts a specific repetition of ROL (Role)
252 * </p>
253 *
254 *
255 * @see AbstractGroup#insertRepetition(Structure, int)
256 */
257 public ROL insertROL(int rep) throws HL7Exception {
258 return (ROL)super.insertRepetition("ROL", rep);
259 }
260
261
262 /**
263 * <p>
264 * Removes a specific repetition of ROL (Role)
265 * </p>
266 *
267 *
268 * @see AbstractGroup#removeRepetition(String, int)
269 */
270 public ROL removeROL(int rep) throws HL7Exception {
271 return (ROL)super.removeRepetition("ROL", rep);
272 }
273
274
275
276
277 /**
278 * <p>
279 * Returns
280 * PV1 (Patient visit) - creates it if necessary
281 * </p>
282 *
283 *
284 */
285 public PV1 getPV1() {
286 return getTyped("PV1", PV1.class);
287 }
288
289
290
291
292
293 /**
294 * <p>
295 * Returns
296 * PV2 (Patient visit - additional information) - creates it if necessary
297 * </p>
298 *
299 *
300 */
301 public PV2 getPV2() {
302 return getTyped("PV2", PV2.class);
303 }
304
305
306
307
308
309 /**
310 * <p>
311 * Returns
312 * the first repetition of
313 * ROL2 (Role) - creates it if necessary
314 * </p>
315 *
316 *
317 */
318 public ROL getROL2() {
319 return getTyped("ROL2", ROL.class);
320 }
321
322
323 /**
324 * <p>
325 * Returns a specific repetition of
326 * ROL2 (Role) - creates it if necessary
327 * </p>
328 *
329 *
330 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
331 * @throws HL7Exception if the repetition requested is more than one
332 * greater than the number of existing repetitions.
333 */
334 public ROL getROL2(int rep) {
335 return getTyped("ROL2", rep, ROL.class);
336 }
337
338 /**
339 * <p>
340 * Returns the number of existing repetitions of ROL2
341 * </p>
342 *
343 */
344 public int getROL2Reps() {
345 return getReps("ROL2");
346 }
347
348 /**
349 * <p>
350 * Returns a non-modifiable List containing all current existing repetitions of ROL2.
351 * <p>
352 * <p>
353 * Note that unlike {@link #getROL2()}, this method will not create any reps
354 * if none are already present, so an empty list may be returned.
355 * </p>
356 *
357 */
358 public java.util.List<ROL> getROL2All() throws HL7Exception {
359 return getAllAsList("ROL2", ROL.class);
360 }
361
362 /**
363 * <p>
364 * Inserts a specific repetition of ROL2 (Role)
365 * </p>
366 *
367 *
368 * @see AbstractGroup#insertRepetition(Structure, int)
369 */
370 public void insertROL2(ROL structure, int rep) throws HL7Exception {
371 super.insertRepetition( "ROL2", structure, rep);
372 }
373
374
375 /**
376 * <p>
377 * Inserts a specific repetition of ROL2 (Role)
378 * </p>
379 *
380 *
381 * @see AbstractGroup#insertRepetition(Structure, int)
382 */
383 public ROL insertROL2(int rep) throws HL7Exception {
384 return (ROL)super.insertRepetition("ROL2", rep);
385 }
386
387
388 /**
389 * <p>
390 * Removes a specific repetition of ROL2 (Role)
391 * </p>
392 *
393 *
394 * @see AbstractGroup#removeRepetition(String, int)
395 */
396 public ROL removeROL2(int rep) throws HL7Exception {
397 return (ROL)super.removeRepetition("ROL2", rep);
398 }
399
400
401
402
403 /**
404 * <p>
405 * Returns
406 * the first repetition of
407 * DB1 (Disability) - creates it if necessary
408 * </p>
409 *
410 *
411 */
412 public DB1 getDB1() {
413 return getTyped("DB1", DB1.class);
414 }
415
416
417 /**
418 * <p>
419 * Returns a specific repetition of
420 * DB1 (Disability) - creates it if necessary
421 * </p>
422 *
423 *
424 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
425 * @throws HL7Exception if the repetition requested is more than one
426 * greater than the number of existing repetitions.
427 */
428 public DB1 getDB1(int rep) {
429 return getTyped("DB1", rep, DB1.class);
430 }
431
432 /**
433 * <p>
434 * Returns the number of existing repetitions of DB1
435 * </p>
436 *
437 */
438 public int getDB1Reps() {
439 return getReps("DB1");
440 }
441
442 /**
443 * <p>
444 * Returns a non-modifiable List containing all current existing repetitions of DB1.
445 * <p>
446 * <p>
447 * Note that unlike {@link #getDB1()}, this method will not create any reps
448 * if none are already present, so an empty list may be returned.
449 * </p>
450 *
451 */
452 public java.util.List<DB1> getDB1All() throws HL7Exception {
453 return getAllAsList("DB1", DB1.class);
454 }
455
456 /**
457 * <p>
458 * Inserts a specific repetition of DB1 (Disability)
459 * </p>
460 *
461 *
462 * @see AbstractGroup#insertRepetition(Structure, int)
463 */
464 public void insertDB1(DB1 structure, int rep) throws HL7Exception {
465 super.insertRepetition( "DB1", structure, rep);
466 }
467
468
469 /**
470 * <p>
471 * Inserts a specific repetition of DB1 (Disability)
472 * </p>
473 *
474 *
475 * @see AbstractGroup#insertRepetition(Structure, int)
476 */
477 public DB1 insertDB1(int rep) throws HL7Exception {
478 return (DB1)super.insertRepetition("DB1", rep);
479 }
480
481
482 /**
483 * <p>
484 * Removes a specific repetition of DB1 (Disability)
485 * </p>
486 *
487 *
488 * @see AbstractGroup#removeRepetition(String, int)
489 */
490 public DB1 removeDB1(int rep) throws HL7Exception {
491 return (DB1)super.removeRepetition("DB1", rep);
492 }
493
494
495
496
497 /**
498 * <p>
499 * Returns
500 * the first repetition of
501 * COMMON_ORDER (a Group object) - creates it if necessary
502 * </p>
503 *
504 *
505 */
506 public DFT_P11_COMMON_ORDER getCOMMON_ORDER() {
507 return getTyped("COMMON_ORDER", DFT_P11_COMMON_ORDER.class);
508 }
509
510
511 /**
512 * <p>
513 * Returns a specific repetition of
514 * COMMON_ORDER (a Group object) - 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 DFT_P11_COMMON_ORDER getCOMMON_ORDER(int rep) {
523 return getTyped("COMMON_ORDER", rep, DFT_P11_COMMON_ORDER.class);
524 }
525
526 /**
527 * <p>
528 * Returns the number of existing repetitions of COMMON_ORDER
529 * </p>
530 *
531 */
532 public int getCOMMON_ORDERReps() {
533 return getReps("COMMON_ORDER");
534 }
535
536 /**
537 * <p>
538 * Returns a non-modifiable List containing all current existing repetitions of COMMON_ORDER.
539 * <p>
540 * <p>
541 * Note that unlike {@link #getCOMMON_ORDER()}, 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<DFT_P11_COMMON_ORDER> getCOMMON_ORDERAll() throws HL7Exception {
547 return getAllAsList("COMMON_ORDER", DFT_P11_COMMON_ORDER.class);
548 }
549
550 /**
551 * <p>
552 * Inserts a specific repetition of COMMON_ORDER (a Group object)
553 * </p>
554 *
555 *
556 * @see AbstractGroup#insertRepetition(Structure, int)
557 */
558 public void insertCOMMON_ORDER(DFT_P11_COMMON_ORDER structure, int rep) throws HL7Exception {
559 super.insertRepetition( "COMMON_ORDER", structure, rep);
560 }
561
562
563 /**
564 * <p>
565 * Inserts a specific repetition of COMMON_ORDER (a Group object)
566 * </p>
567 *
568 *
569 * @see AbstractGroup#insertRepetition(Structure, int)
570 */
571 public DFT_P11_COMMON_ORDER insertCOMMON_ORDER(int rep) throws HL7Exception {
572 return (DFT_P11_COMMON_ORDER)super.insertRepetition("COMMON_ORDER", rep);
573 }
574
575
576 /**
577 * <p>
578 * Removes a specific repetition of COMMON_ORDER (a Group object)
579 * </p>
580 *
581 *
582 * @see AbstractGroup#removeRepetition(String, int)
583 */
584 public DFT_P11_COMMON_ORDER removeCOMMON_ORDER(int rep) throws HL7Exception {
585 return (DFT_P11_COMMON_ORDER)super.removeRepetition("COMMON_ORDER", rep);
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 * DRG (Diagnosis Related Group) - creates it if necessary
689 * </p>
690 *
691 *
692 */
693 public DRG getDRG() {
694 return getTyped("DRG", DRG.class);
695 }
696
697
698
699
700
701 /**
702 * <p>
703 * Returns
704 * the first repetition of
705 * GT1 (Guarantor) - creates it if necessary
706 * </p>
707 *
708 *
709 */
710 public GT1 getGT1() {
711 return getTyped("GT1", GT1.class);
712 }
713
714
715 /**
716 * <p>
717 * Returns a specific repetition of
718 * GT1 (Guarantor) - creates it if necessary
719 * </p>
720 *
721 *
722 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
723 * @throws HL7Exception if the repetition requested is more than one
724 * greater than the number of existing repetitions.
725 */
726 public GT1 getGT1(int rep) {
727 return getTyped("GT1", rep, GT1.class);
728 }
729
730 /**
731 * <p>
732 * Returns the number of existing repetitions of GT1
733 * </p>
734 *
735 */
736 public int getGT1Reps() {
737 return getReps("GT1");
738 }
739
740 /**
741 * <p>
742 * Returns a non-modifiable List containing all current existing repetitions of GT1.
743 * <p>
744 * <p>
745 * Note that unlike {@link #getGT1()}, this method will not create any reps
746 * if none are already present, so an empty list may be returned.
747 * </p>
748 *
749 */
750 public java.util.List<GT1> getGT1All() throws HL7Exception {
751 return getAllAsList("GT1", GT1.class);
752 }
753
754 /**
755 * <p>
756 * Inserts a specific repetition of GT1 (Guarantor)
757 * </p>
758 *
759 *
760 * @see AbstractGroup#insertRepetition(Structure, int)
761 */
762 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
763 super.insertRepetition( "GT1", structure, rep);
764 }
765
766
767 /**
768 * <p>
769 * Inserts a specific repetition of GT1 (Guarantor)
770 * </p>
771 *
772 *
773 * @see AbstractGroup#insertRepetition(Structure, int)
774 */
775 public GT1 insertGT1(int rep) throws HL7Exception {
776 return (GT1)super.insertRepetition("GT1", rep);
777 }
778
779
780 /**
781 * <p>
782 * Removes a specific repetition of GT1 (Guarantor)
783 * </p>
784 *
785 *
786 * @see AbstractGroup#removeRepetition(String, int)
787 */
788 public GT1 removeGT1(int rep) throws HL7Exception {
789 return (GT1)super.removeRepetition("GT1", rep);
790 }
791
792
793
794
795 /**
796 * <p>
797 * Returns
798 * the first repetition of
799 * INSURANCE (a Group object) - creates it if necessary
800 * </p>
801 *
802 *
803 */
804 public DFT_P11_INSURANCE getINSURANCE() {
805 return getTyped("INSURANCE", DFT_P11_INSURANCE.class);
806 }
807
808
809 /**
810 * <p>
811 * Returns a specific repetition of
812 * INSURANCE (a Group object) - creates it if necessary
813 * </p>
814 *
815 *
816 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
817 * @throws HL7Exception if the repetition requested is more than one
818 * greater than the number of existing repetitions.
819 */
820 public DFT_P11_INSURANCE getINSURANCE(int rep) {
821 return getTyped("INSURANCE", rep, DFT_P11_INSURANCE.class);
822 }
823
824 /**
825 * <p>
826 * Returns the number of existing repetitions of INSURANCE
827 * </p>
828 *
829 */
830 public int getINSURANCEReps() {
831 return getReps("INSURANCE");
832 }
833
834 /**
835 * <p>
836 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
837 * <p>
838 * <p>
839 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
840 * if none are already present, so an empty list may be returned.
841 * </p>
842 *
843 */
844 public java.util.List<DFT_P11_INSURANCE> getINSURANCEAll() throws HL7Exception {
845 return getAllAsList("INSURANCE", DFT_P11_INSURANCE.class);
846 }
847
848 /**
849 * <p>
850 * Inserts a specific repetition of INSURANCE (a Group object)
851 * </p>
852 *
853 *
854 * @see AbstractGroup#insertRepetition(Structure, int)
855 */
856 public void insertINSURANCE(DFT_P11_INSURANCE structure, int rep) throws HL7Exception {
857 super.insertRepetition( "INSURANCE", structure, rep);
858 }
859
860
861 /**
862 * <p>
863 * Inserts a specific repetition of INSURANCE (a Group object)
864 * </p>
865 *
866 *
867 * @see AbstractGroup#insertRepetition(Structure, int)
868 */
869 public DFT_P11_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
870 return (DFT_P11_INSURANCE)super.insertRepetition("INSURANCE", rep);
871 }
872
873
874 /**
875 * <p>
876 * Removes a specific repetition of INSURANCE (a Group object)
877 * </p>
878 *
879 *
880 * @see AbstractGroup#removeRepetition(String, int)
881 */
882 public DFT_P11_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
883 return (DFT_P11_INSURANCE)super.removeRepetition("INSURANCE", rep);
884 }
885
886
887
888
889 /**
890 * <p>
891 * Returns
892 * ACC (Accident) - creates it if necessary
893 * </p>
894 *
895 *
896 */
897 public ACC getACC() {
898 return getTyped("ACC", ACC.class);
899 }
900
901
902
903
904
905 /**
906 * <p>
907 * Returns
908 * the first repetition of
909 * FINANCIAL (a Group object) - creates it if necessary
910 * </p>
911 *
912 *
913 */
914 public DFT_P11_FINANCIAL getFINANCIAL() {
915 return getTyped("FINANCIAL", DFT_P11_FINANCIAL.class);
916 }
917
918
919 /**
920 * <p>
921 * Returns a specific repetition of
922 * FINANCIAL (a Group object) - creates it if necessary
923 * </p>
924 *
925 *
926 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
927 * @throws HL7Exception if the repetition requested is more than one
928 * greater than the number of existing repetitions.
929 */
930 public DFT_P11_FINANCIAL getFINANCIAL(int rep) {
931 return getTyped("FINANCIAL", rep, DFT_P11_FINANCIAL.class);
932 }
933
934 /**
935 * <p>
936 * Returns the number of existing repetitions of FINANCIAL
937 * </p>
938 *
939 */
940 public int getFINANCIALReps() {
941 return getReps("FINANCIAL");
942 }
943
944 /**
945 * <p>
946 * Returns a non-modifiable List containing all current existing repetitions of FINANCIAL.
947 * <p>
948 * <p>
949 * Note that unlike {@link #getFINANCIAL()}, this method will not create any reps
950 * if none are already present, so an empty list may be returned.
951 * </p>
952 *
953 */
954 public java.util.List<DFT_P11_FINANCIAL> getFINANCIALAll() throws HL7Exception {
955 return getAllAsList("FINANCIAL", DFT_P11_FINANCIAL.class);
956 }
957
958 /**
959 * <p>
960 * Inserts a specific repetition of FINANCIAL (a Group object)
961 * </p>
962 *
963 *
964 * @see AbstractGroup#insertRepetition(Structure, int)
965 */
966 public void insertFINANCIAL(DFT_P11_FINANCIAL structure, int rep) throws HL7Exception {
967 super.insertRepetition( "FINANCIAL", structure, rep);
968 }
969
970
971 /**
972 * <p>
973 * Inserts a specific repetition of FINANCIAL (a Group object)
974 * </p>
975 *
976 *
977 * @see AbstractGroup#insertRepetition(Structure, int)
978 */
979 public DFT_P11_FINANCIAL insertFINANCIAL(int rep) throws HL7Exception {
980 return (DFT_P11_FINANCIAL)super.insertRepetition("FINANCIAL", rep);
981 }
982
983
984 /**
985 * <p>
986 * Removes a specific repetition of FINANCIAL (a Group object)
987 * </p>
988 *
989 *
990 * @see AbstractGroup#removeRepetition(String, int)
991 */
992 public DFT_P11_FINANCIAL removeFINANCIAL(int rep) throws HL7Exception {
993 return (DFT_P11_FINANCIAL)super.removeRepetition("FINANCIAL", rep);
994 }
995
996
997
998 }
999