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