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 ADT_A06 message structure (see chapter 3.3.6). 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: EVN (Event Type) <b> </b> </li>
52 * <li>4: PID (Patient Identification) <b> </b> </li>
53 * <li>5: PD1 (Patient Additional Demographic) <b>optional </b> </li>
54 * <li>6: ROL (Role) <b>optional repeating</b> </li>
55 * <li>7: MRG (Merge Patient Information) <b>optional </b> </li>
56 * <li>8: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li>
57 * <li>9: PV1 (Patient Visit) <b> </b> </li>
58 * <li>10: PV2 (Patient Visit - Additional Information) <b>optional </b> </li>
59 * <li>11: ROL (Role) <b>optional repeating</b> </li>
60 * <li>12: DB1 (Disability) <b>optional repeating</b> </li>
61 * <li>13: OBX (Observation/Result) <b>optional repeating</b> </li>
62 * <li>14: AL1 (Patient Allergy Information) <b>optional repeating</b> </li>
63 * <li>15: DG1 (Diagnosis) <b>optional repeating</b> </li>
64 * <li>16: DRG (Diagnosis Related Group) <b>optional </b> </li>
65 * <li>17: ADT_A06_PROCEDURE (a Group object) <b>optional repeating</b> </li>
66 * <li>18: GT1 (Guarantor) <b>optional repeating</b> </li>
67 * <li>19: ADT_A06_INSURANCE (a Group object) <b>optional repeating</b> </li>
68 * <li>20: ACC (Accident) <b>optional </b> </li>
69 * <li>21: UB1 (UB82) <b>optional </b> </li>
70 * <li>22: UB2 (UB92 Data) <b>optional </b> </li>
71 * </ul>
72 */
73 //@SuppressWarnings("unused")
74 public class ADT_A06 extends AbstractMessage {
75
76 /**
77 * Creates a new ADT_A06 message with DefaultModelClassFactory.
78 */
79 public ADT_A06() {
80 this(new DefaultModelClassFactory());
81 }
82
83 /**
84 * Creates a new ADT_A06 message with custom ModelClassFactory.
85 */
86 public ADT_A06(ModelClassFactory factory) {
87 super(factory);
88 init(factory);
89 }
90
91 private void init(ModelClassFactory factory) {
92 try {
93 this.add(MSH.class, true, false);
94 this.add(SFT.class, false, true);
95 this.add(EVN.class, true, false);
96 this.add(PID.class, true, false);
97 this.add(PD1.class, false, false);
98 this.add(ROL.class, false, true);
99 this.add(MRG.class, false, false);
100 this.add(NK1.class, false, true);
101 this.add(PV1.class, true, false);
102 this.add(PV2.class, false, false);
103 this.add(ROL.class, false, true);
104 this.add(DB1.class, false, true);
105 this.add(OBX.class, false, true);
106 this.add(AL1.class, false, true);
107 this.add(DG1.class, false, true);
108 this.add(DRG.class, false, false);
109 this.add(ADT_A06_PROCEDURE.class, false, true);
110 this.add(GT1.class, false, true);
111 this.add(ADT_A06_INSURANCE.class, false, true);
112 this.add(ACC.class, false, false);
113 this.add(UB1.class, false, false);
114 this.add(UB2.class, false, false);
115 } catch(HL7Exception e) {
116 log.error("Unexpected error creating ADT_A06 - this is probably a bug in the source code generator.", e);
117 }
118 }
119
120
121 /**
122 * Returns "2.5.1"
123 */
124 public String getVersion() {
125 return "2.5.1";
126 }
127
128
129
130
131 /**
132 * <p>
133 * Returns
134 * MSH (Message Header) - creates it if necessary
135 * </p>
136 *
137 *
138 */
139 public MSH getMSH() {
140 return getTyped("MSH", MSH.class);
141 }
142
143
144
145
146
147 /**
148 * <p>
149 * Returns
150 * the first repetition of
151 * SFT (Software Segment) - creates it if necessary
152 * </p>
153 *
154 *
155 */
156 public SFT getSFT() {
157 return getTyped("SFT", SFT.class);
158 }
159
160
161 /**
162 * <p>
163 * Returns a specific repetition of
164 * SFT (Software Segment) - creates it if necessary
165 * </p>
166 *
167 *
168 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
169 * @throws HL7Exception if the repetition requested is more than one
170 * greater than the number of existing repetitions.
171 */
172 public SFT getSFT(int rep) {
173 return getTyped("SFT", rep, SFT.class);
174 }
175
176 /**
177 * <p>
178 * Returns the number of existing repetitions of SFT
179 * </p>
180 *
181 */
182 public int getSFTReps() {
183 return getReps("SFT");
184 }
185
186 /**
187 * <p>
188 * Returns a non-modifiable List containing all current existing repetitions of SFT.
189 * <p>
190 * <p>
191 * Note that unlike {@link #getSFT()}, this method will not create any reps
192 * if none are already present, so an empty list may be returned.
193 * </p>
194 *
195 */
196 public java.util.List<SFT> getSFTAll() throws HL7Exception {
197 return getAllAsList("SFT", SFT.class);
198 }
199
200 /**
201 * <p>
202 * Inserts a specific repetition of SFT (Software Segment)
203 * </p>
204 *
205 *
206 * @see AbstractGroup#insertRepetition(Structure, int)
207 */
208 public void insertSFT(SFT structure, int rep) throws HL7Exception {
209 super.insertRepetition( "SFT", structure, rep);
210 }
211
212
213 /**
214 * <p>
215 * Inserts a specific repetition of SFT (Software Segment)
216 * </p>
217 *
218 *
219 * @see AbstractGroup#insertRepetition(Structure, int)
220 */
221 public SFT insertSFT(int rep) throws HL7Exception {
222 return (SFT)super.insertRepetition("SFT", rep);
223 }
224
225
226 /**
227 * <p>
228 * Removes a specific repetition of SFT (Software Segment)
229 * </p>
230 *
231 *
232 * @see AbstractGroup#removeRepetition(String, int)
233 */
234 public SFT removeSFT(int rep) throws HL7Exception {
235 return (SFT)super.removeRepetition("SFT", rep);
236 }
237
238
239
240
241 /**
242 * <p>
243 * Returns
244 * EVN (Event Type) - creates it if necessary
245 * </p>
246 *
247 *
248 */
249 public EVN getEVN() {
250 return getTyped("EVN", EVN.class);
251 }
252
253
254
255
256
257 /**
258 * <p>
259 * Returns
260 * PID (Patient Identification) - creates it if necessary
261 * </p>
262 *
263 *
264 */
265 public PID getPID() {
266 return getTyped("PID", PID.class);
267 }
268
269
270
271
272
273 /**
274 * <p>
275 * Returns
276 * PD1 (Patient Additional Demographic) - creates it if necessary
277 * </p>
278 *
279 *
280 */
281 public PD1 getPD1() {
282 return getTyped("PD1", PD1.class);
283 }
284
285
286
287
288
289 /**
290 * <p>
291 * Returns
292 * the first repetition of
293 * ROL (Role) - creates it if necessary
294 * </p>
295 *
296 *
297 */
298 public ROL getROL() {
299 return getTyped("ROL", ROL.class);
300 }
301
302
303 /**
304 * <p>
305 * Returns a specific repetition of
306 * ROL (Role) - creates it if necessary
307 * </p>
308 *
309 *
310 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
311 * @throws HL7Exception if the repetition requested is more than one
312 * greater than the number of existing repetitions.
313 */
314 public ROL getROL(int rep) {
315 return getTyped("ROL", rep, ROL.class);
316 }
317
318 /**
319 * <p>
320 * Returns the number of existing repetitions of ROL
321 * </p>
322 *
323 */
324 public int getROLReps() {
325 return getReps("ROL");
326 }
327
328 /**
329 * <p>
330 * Returns a non-modifiable List containing all current existing repetitions of ROL.
331 * <p>
332 * <p>
333 * Note that unlike {@link #getROL()}, this method will not create any reps
334 * if none are already present, so an empty list may be returned.
335 * </p>
336 *
337 */
338 public java.util.List<ROL> getROLAll() throws HL7Exception {
339 return getAllAsList("ROL", ROL.class);
340 }
341
342 /**
343 * <p>
344 * Inserts a specific repetition of ROL (Role)
345 * </p>
346 *
347 *
348 * @see AbstractGroup#insertRepetition(Structure, int)
349 */
350 public void insertROL(ROL structure, int rep) throws HL7Exception {
351 super.insertRepetition( "ROL", structure, rep);
352 }
353
354
355 /**
356 * <p>
357 * Inserts a specific repetition of ROL (Role)
358 * </p>
359 *
360 *
361 * @see AbstractGroup#insertRepetition(Structure, int)
362 */
363 public ROL insertROL(int rep) throws HL7Exception {
364 return (ROL)super.insertRepetition("ROL", rep);
365 }
366
367
368 /**
369 * <p>
370 * Removes a specific repetition of ROL (Role)
371 * </p>
372 *
373 *
374 * @see AbstractGroup#removeRepetition(String, int)
375 */
376 public ROL removeROL(int rep) throws HL7Exception {
377 return (ROL)super.removeRepetition("ROL", rep);
378 }
379
380
381
382
383 /**
384 * <p>
385 * Returns
386 * MRG (Merge Patient Information) - creates it if necessary
387 * </p>
388 *
389 *
390 */
391 public MRG getMRG() {
392 return getTyped("MRG", MRG.class);
393 }
394
395
396
397
398
399 /**
400 * <p>
401 * Returns
402 * the first repetition of
403 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
404 * </p>
405 *
406 *
407 */
408 public NK1 getNK1() {
409 return getTyped("NK1", NK1.class);
410 }
411
412
413 /**
414 * <p>
415 * Returns a specific repetition of
416 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
417 * </p>
418 *
419 *
420 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
421 * @throws HL7Exception if the repetition requested is more than one
422 * greater than the number of existing repetitions.
423 */
424 public NK1 getNK1(int rep) {
425 return getTyped("NK1", rep, NK1.class);
426 }
427
428 /**
429 * <p>
430 * Returns the number of existing repetitions of NK1
431 * </p>
432 *
433 */
434 public int getNK1Reps() {
435 return getReps("NK1");
436 }
437
438 /**
439 * <p>
440 * Returns a non-modifiable List containing all current existing repetitions of NK1.
441 * <p>
442 * <p>
443 * Note that unlike {@link #getNK1()}, this method will not create any reps
444 * if none are already present, so an empty list may be returned.
445 * </p>
446 *
447 */
448 public java.util.List<NK1> getNK1All() throws HL7Exception {
449 return getAllAsList("NK1", NK1.class);
450 }
451
452 /**
453 * <p>
454 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
455 * </p>
456 *
457 *
458 * @see AbstractGroup#insertRepetition(Structure, int)
459 */
460 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
461 super.insertRepetition( "NK1", structure, rep);
462 }
463
464
465 /**
466 * <p>
467 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
468 * </p>
469 *
470 *
471 * @see AbstractGroup#insertRepetition(Structure, int)
472 */
473 public NK1 insertNK1(int rep) throws HL7Exception {
474 return (NK1)super.insertRepetition("NK1", rep);
475 }
476
477
478 /**
479 * <p>
480 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties)
481 * </p>
482 *
483 *
484 * @see AbstractGroup#removeRepetition(String, int)
485 */
486 public NK1 removeNK1(int rep) throws HL7Exception {
487 return (NK1)super.removeRepetition("NK1", rep);
488 }
489
490
491
492
493 /**
494 * <p>
495 * Returns
496 * PV1 (Patient Visit) - creates it if necessary
497 * </p>
498 *
499 *
500 */
501 public PV1 getPV1() {
502 return getTyped("PV1", PV1.class);
503 }
504
505
506
507
508
509 /**
510 * <p>
511 * Returns
512 * PV2 (Patient Visit - Additional Information) - creates it if necessary
513 * </p>
514 *
515 *
516 */
517 public PV2 getPV2() {
518 return getTyped("PV2", PV2.class);
519 }
520
521
522
523
524
525 /**
526 * <p>
527 * Returns
528 * the first repetition of
529 * ROL2 (Role) - creates it if necessary
530 * </p>
531 *
532 *
533 */
534 public ROL getROL2() {
535 return getTyped("ROL2", ROL.class);
536 }
537
538
539 /**
540 * <p>
541 * Returns a specific repetition of
542 * ROL2 (Role) - creates it if necessary
543 * </p>
544 *
545 *
546 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
547 * @throws HL7Exception if the repetition requested is more than one
548 * greater than the number of existing repetitions.
549 */
550 public ROL getROL2(int rep) {
551 return getTyped("ROL2", rep, ROL.class);
552 }
553
554 /**
555 * <p>
556 * Returns the number of existing repetitions of ROL2
557 * </p>
558 *
559 */
560 public int getROL2Reps() {
561 return getReps("ROL2");
562 }
563
564 /**
565 * <p>
566 * Returns a non-modifiable List containing all current existing repetitions of ROL2.
567 * <p>
568 * <p>
569 * Note that unlike {@link #getROL2()}, this method will not create any reps
570 * if none are already present, so an empty list may be returned.
571 * </p>
572 *
573 */
574 public java.util.List<ROL> getROL2All() throws HL7Exception {
575 return getAllAsList("ROL2", ROL.class);
576 }
577
578 /**
579 * <p>
580 * Inserts a specific repetition of ROL2 (Role)
581 * </p>
582 *
583 *
584 * @see AbstractGroup#insertRepetition(Structure, int)
585 */
586 public void insertROL2(ROL structure, int rep) throws HL7Exception {
587 super.insertRepetition( "ROL2", structure, rep);
588 }
589
590
591 /**
592 * <p>
593 * Inserts a specific repetition of ROL2 (Role)
594 * </p>
595 *
596 *
597 * @see AbstractGroup#insertRepetition(Structure, int)
598 */
599 public ROL insertROL2(int rep) throws HL7Exception {
600 return (ROL)super.insertRepetition("ROL2", rep);
601 }
602
603
604 /**
605 * <p>
606 * Removes a specific repetition of ROL2 (Role)
607 * </p>
608 *
609 *
610 * @see AbstractGroup#removeRepetition(String, int)
611 */
612 public ROL removeROL2(int rep) throws HL7Exception {
613 return (ROL)super.removeRepetition("ROL2", rep);
614 }
615
616
617
618
619 /**
620 * <p>
621 * Returns
622 * the first repetition of
623 * DB1 (Disability) - creates it if necessary
624 * </p>
625 *
626 *
627 */
628 public DB1 getDB1() {
629 return getTyped("DB1", DB1.class);
630 }
631
632
633 /**
634 * <p>
635 * Returns a specific repetition of
636 * DB1 (Disability) - creates it if necessary
637 * </p>
638 *
639 *
640 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
641 * @throws HL7Exception if the repetition requested is more than one
642 * greater than the number of existing repetitions.
643 */
644 public DB1 getDB1(int rep) {
645 return getTyped("DB1", rep, DB1.class);
646 }
647
648 /**
649 * <p>
650 * Returns the number of existing repetitions of DB1
651 * </p>
652 *
653 */
654 public int getDB1Reps() {
655 return getReps("DB1");
656 }
657
658 /**
659 * <p>
660 * Returns a non-modifiable List containing all current existing repetitions of DB1.
661 * <p>
662 * <p>
663 * Note that unlike {@link #getDB1()}, this method will not create any reps
664 * if none are already present, so an empty list may be returned.
665 * </p>
666 *
667 */
668 public java.util.List<DB1> getDB1All() throws HL7Exception {
669 return getAllAsList("DB1", DB1.class);
670 }
671
672 /**
673 * <p>
674 * Inserts a specific repetition of DB1 (Disability)
675 * </p>
676 *
677 *
678 * @see AbstractGroup#insertRepetition(Structure, int)
679 */
680 public void insertDB1(DB1 structure, int rep) throws HL7Exception {
681 super.insertRepetition( "DB1", structure, rep);
682 }
683
684
685 /**
686 * <p>
687 * Inserts a specific repetition of DB1 (Disability)
688 * </p>
689 *
690 *
691 * @see AbstractGroup#insertRepetition(Structure, int)
692 */
693 public DB1 insertDB1(int rep) throws HL7Exception {
694 return (DB1)super.insertRepetition("DB1", rep);
695 }
696
697
698 /**
699 * <p>
700 * Removes a specific repetition of DB1 (Disability)
701 * </p>
702 *
703 *
704 * @see AbstractGroup#removeRepetition(String, int)
705 */
706 public DB1 removeDB1(int rep) throws HL7Exception {
707 return (DB1)super.removeRepetition("DB1", rep);
708 }
709
710
711
712
713 /**
714 * <p>
715 * Returns
716 * the first repetition of
717 * OBX (Observation/Result) - creates it if necessary
718 * </p>
719 *
720 *
721 */
722 public OBX getOBX() {
723 return getTyped("OBX", OBX.class);
724 }
725
726
727 /**
728 * <p>
729 * Returns a specific repetition of
730 * OBX (Observation/Result) - creates it if necessary
731 * </p>
732 *
733 *
734 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
735 * @throws HL7Exception if the repetition requested is more than one
736 * greater than the number of existing repetitions.
737 */
738 public OBX getOBX(int rep) {
739 return getTyped("OBX", rep, OBX.class);
740 }
741
742 /**
743 * <p>
744 * Returns the number of existing repetitions of OBX
745 * </p>
746 *
747 */
748 public int getOBXReps() {
749 return getReps("OBX");
750 }
751
752 /**
753 * <p>
754 * Returns a non-modifiable List containing all current existing repetitions of OBX.
755 * <p>
756 * <p>
757 * Note that unlike {@link #getOBX()}, this method will not create any reps
758 * if none are already present, so an empty list may be returned.
759 * </p>
760 *
761 */
762 public java.util.List<OBX> getOBXAll() throws HL7Exception {
763 return getAllAsList("OBX", OBX.class);
764 }
765
766 /**
767 * <p>
768 * Inserts a specific repetition of OBX (Observation/Result)
769 * </p>
770 *
771 *
772 * @see AbstractGroup#insertRepetition(Structure, int)
773 */
774 public void insertOBX(OBX structure, int rep) throws HL7Exception {
775 super.insertRepetition( "OBX", structure, rep);
776 }
777
778
779 /**
780 * <p>
781 * Inserts a specific repetition of OBX (Observation/Result)
782 * </p>
783 *
784 *
785 * @see AbstractGroup#insertRepetition(Structure, int)
786 */
787 public OBX insertOBX(int rep) throws HL7Exception {
788 return (OBX)super.insertRepetition("OBX", rep);
789 }
790
791
792 /**
793 * <p>
794 * Removes a specific repetition of OBX (Observation/Result)
795 * </p>
796 *
797 *
798 * @see AbstractGroup#removeRepetition(String, int)
799 */
800 public OBX removeOBX(int rep) throws HL7Exception {
801 return (OBX)super.removeRepetition("OBX", rep);
802 }
803
804
805
806
807 /**
808 * <p>
809 * Returns
810 * the first repetition of
811 * AL1 (Patient Allergy Information) - creates it if necessary
812 * </p>
813 *
814 *
815 */
816 public AL1 getAL1() {
817 return getTyped("AL1", AL1.class);
818 }
819
820
821 /**
822 * <p>
823 * Returns a specific repetition of
824 * AL1 (Patient Allergy Information) - creates it if necessary
825 * </p>
826 *
827 *
828 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
829 * @throws HL7Exception if the repetition requested is more than one
830 * greater than the number of existing repetitions.
831 */
832 public AL1 getAL1(int rep) {
833 return getTyped("AL1", rep, AL1.class);
834 }
835
836 /**
837 * <p>
838 * Returns the number of existing repetitions of AL1
839 * </p>
840 *
841 */
842 public int getAL1Reps() {
843 return getReps("AL1");
844 }
845
846 /**
847 * <p>
848 * Returns a non-modifiable List containing all current existing repetitions of AL1.
849 * <p>
850 * <p>
851 * Note that unlike {@link #getAL1()}, this method will not create any reps
852 * if none are already present, so an empty list may be returned.
853 * </p>
854 *
855 */
856 public java.util.List<AL1> getAL1All() throws HL7Exception {
857 return getAllAsList("AL1", AL1.class);
858 }
859
860 /**
861 * <p>
862 * Inserts a specific repetition of AL1 (Patient Allergy Information)
863 * </p>
864 *
865 *
866 * @see AbstractGroup#insertRepetition(Structure, int)
867 */
868 public void insertAL1(AL1 structure, int rep) throws HL7Exception {
869 super.insertRepetition( "AL1", structure, rep);
870 }
871
872
873 /**
874 * <p>
875 * Inserts a specific repetition of AL1 (Patient Allergy Information)
876 * </p>
877 *
878 *
879 * @see AbstractGroup#insertRepetition(Structure, int)
880 */
881 public AL1 insertAL1(int rep) throws HL7Exception {
882 return (AL1)super.insertRepetition("AL1", rep);
883 }
884
885
886 /**
887 * <p>
888 * Removes a specific repetition of AL1 (Patient Allergy Information)
889 * </p>
890 *
891 *
892 * @see AbstractGroup#removeRepetition(String, int)
893 */
894 public AL1 removeAL1(int rep) throws HL7Exception {
895 return (AL1)super.removeRepetition("AL1", rep);
896 }
897
898
899
900
901 /**
902 * <p>
903 * Returns
904 * the first repetition of
905 * DG1 (Diagnosis) - creates it if necessary
906 * </p>
907 *
908 *
909 */
910 public DG1 getDG1() {
911 return getTyped("DG1", DG1.class);
912 }
913
914
915 /**
916 * <p>
917 * Returns a specific repetition of
918 * DG1 (Diagnosis) - creates it if necessary
919 * </p>
920 *
921 *
922 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
923 * @throws HL7Exception if the repetition requested is more than one
924 * greater than the number of existing repetitions.
925 */
926 public DG1 getDG1(int rep) {
927 return getTyped("DG1", rep, DG1.class);
928 }
929
930 /**
931 * <p>
932 * Returns the number of existing repetitions of DG1
933 * </p>
934 *
935 */
936 public int getDG1Reps() {
937 return getReps("DG1");
938 }
939
940 /**
941 * <p>
942 * Returns a non-modifiable List containing all current existing repetitions of DG1.
943 * <p>
944 * <p>
945 * Note that unlike {@link #getDG1()}, this method will not create any reps
946 * if none are already present, so an empty list may be returned.
947 * </p>
948 *
949 */
950 public java.util.List<DG1> getDG1All() throws HL7Exception {
951 return getAllAsList("DG1", DG1.class);
952 }
953
954 /**
955 * <p>
956 * Inserts a specific repetition of DG1 (Diagnosis)
957 * </p>
958 *
959 *
960 * @see AbstractGroup#insertRepetition(Structure, int)
961 */
962 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
963 super.insertRepetition( "DG1", structure, rep);
964 }
965
966
967 /**
968 * <p>
969 * Inserts a specific repetition of DG1 (Diagnosis)
970 * </p>
971 *
972 *
973 * @see AbstractGroup#insertRepetition(Structure, int)
974 */
975 public DG1 insertDG1(int rep) throws HL7Exception {
976 return (DG1)super.insertRepetition("DG1", rep);
977 }
978
979
980 /**
981 * <p>
982 * Removes a specific repetition of DG1 (Diagnosis)
983 * </p>
984 *
985 *
986 * @see AbstractGroup#removeRepetition(String, int)
987 */
988 public DG1 removeDG1(int rep) throws HL7Exception {
989 return (DG1)super.removeRepetition("DG1", rep);
990 }
991
992
993
994
995 /**
996 * <p>
997 * Returns
998 * DRG (Diagnosis Related Group) - creates it if necessary
999 * </p>
1000 *
1001 *
1002 */
1003 public DRG getDRG() {
1004 return getTyped("DRG", DRG.class);
1005 }
1006
1007
1008
1009
1010
1011 /**
1012 * <p>
1013 * Returns
1014 * the first repetition of
1015 * PROCEDURE (a Group object) - creates it if necessary
1016 * </p>
1017 *
1018 *
1019 */
1020 public ADT_A06_PROCEDURE getPROCEDURE() {
1021 return getTyped("PROCEDURE", ADT_A06_PROCEDURE.class);
1022 }
1023
1024
1025 /**
1026 * <p>
1027 * Returns a specific repetition of
1028 * PROCEDURE (a Group object) - creates it if necessary
1029 * </p>
1030 *
1031 *
1032 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1033 * @throws HL7Exception if the repetition requested is more than one
1034 * greater than the number of existing repetitions.
1035 */
1036 public ADT_A06_PROCEDURE getPROCEDURE(int rep) {
1037 return getTyped("PROCEDURE", rep, ADT_A06_PROCEDURE.class);
1038 }
1039
1040 /**
1041 * <p>
1042 * Returns the number of existing repetitions of PROCEDURE
1043 * </p>
1044 *
1045 */
1046 public int getPROCEDUREReps() {
1047 return getReps("PROCEDURE");
1048 }
1049
1050 /**
1051 * <p>
1052 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE.
1053 * <p>
1054 * <p>
1055 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps
1056 * if none are already present, so an empty list may be returned.
1057 * </p>
1058 *
1059 */
1060 public java.util.List<ADT_A06_PROCEDURE> getPROCEDUREAll() throws HL7Exception {
1061 return getAllAsList("PROCEDURE", ADT_A06_PROCEDURE.class);
1062 }
1063
1064 /**
1065 * <p>
1066 * Inserts a specific repetition of PROCEDURE (a Group object)
1067 * </p>
1068 *
1069 *
1070 * @see AbstractGroup#insertRepetition(Structure, int)
1071 */
1072 public void insertPROCEDURE(ADT_A06_PROCEDURE structure, int rep) throws HL7Exception {
1073 super.insertRepetition( "PROCEDURE", structure, rep);
1074 }
1075
1076
1077 /**
1078 * <p>
1079 * Inserts a specific repetition of PROCEDURE (a Group object)
1080 * </p>
1081 *
1082 *
1083 * @see AbstractGroup#insertRepetition(Structure, int)
1084 */
1085 public ADT_A06_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception {
1086 return (ADT_A06_PROCEDURE)super.insertRepetition("PROCEDURE", rep);
1087 }
1088
1089
1090 /**
1091 * <p>
1092 * Removes a specific repetition of PROCEDURE (a Group object)
1093 * </p>
1094 *
1095 *
1096 * @see AbstractGroup#removeRepetition(String, int)
1097 */
1098 public ADT_A06_PROCEDURE removePROCEDURE(int rep) throws HL7Exception {
1099 return (ADT_A06_PROCEDURE)super.removeRepetition("PROCEDURE", rep);
1100 }
1101
1102
1103
1104
1105 /**
1106 * <p>
1107 * Returns
1108 * the first repetition of
1109 * GT1 (Guarantor) - creates it if necessary
1110 * </p>
1111 *
1112 *
1113 */
1114 public GT1 getGT1() {
1115 return getTyped("GT1", GT1.class);
1116 }
1117
1118
1119 /**
1120 * <p>
1121 * Returns a specific repetition of
1122 * GT1 (Guarantor) - creates it if necessary
1123 * </p>
1124 *
1125 *
1126 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1127 * @throws HL7Exception if the repetition requested is more than one
1128 * greater than the number of existing repetitions.
1129 */
1130 public GT1 getGT1(int rep) {
1131 return getTyped("GT1", rep, GT1.class);
1132 }
1133
1134 /**
1135 * <p>
1136 * Returns the number of existing repetitions of GT1
1137 * </p>
1138 *
1139 */
1140 public int getGT1Reps() {
1141 return getReps("GT1");
1142 }
1143
1144 /**
1145 * <p>
1146 * Returns a non-modifiable List containing all current existing repetitions of GT1.
1147 * <p>
1148 * <p>
1149 * Note that unlike {@link #getGT1()}, this method will not create any reps
1150 * if none are already present, so an empty list may be returned.
1151 * </p>
1152 *
1153 */
1154 public java.util.List<GT1> getGT1All() throws HL7Exception {
1155 return getAllAsList("GT1", GT1.class);
1156 }
1157
1158 /**
1159 * <p>
1160 * Inserts a specific repetition of GT1 (Guarantor)
1161 * </p>
1162 *
1163 *
1164 * @see AbstractGroup#insertRepetition(Structure, int)
1165 */
1166 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
1167 super.insertRepetition( "GT1", structure, rep);
1168 }
1169
1170
1171 /**
1172 * <p>
1173 * Inserts a specific repetition of GT1 (Guarantor)
1174 * </p>
1175 *
1176 *
1177 * @see AbstractGroup#insertRepetition(Structure, int)
1178 */
1179 public GT1 insertGT1(int rep) throws HL7Exception {
1180 return (GT1)super.insertRepetition("GT1", rep);
1181 }
1182
1183
1184 /**
1185 * <p>
1186 * Removes a specific repetition of GT1 (Guarantor)
1187 * </p>
1188 *
1189 *
1190 * @see AbstractGroup#removeRepetition(String, int)
1191 */
1192 public GT1 removeGT1(int rep) throws HL7Exception {
1193 return (GT1)super.removeRepetition("GT1", rep);
1194 }
1195
1196
1197
1198
1199 /**
1200 * <p>
1201 * Returns
1202 * the first repetition of
1203 * INSURANCE (a Group object) - creates it if necessary
1204 * </p>
1205 *
1206 *
1207 */
1208 public ADT_A06_INSURANCE getINSURANCE() {
1209 return getTyped("INSURANCE", ADT_A06_INSURANCE.class);
1210 }
1211
1212
1213 /**
1214 * <p>
1215 * Returns a specific repetition of
1216 * INSURANCE (a Group object) - creates it if necessary
1217 * </p>
1218 *
1219 *
1220 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1221 * @throws HL7Exception if the repetition requested is more than one
1222 * greater than the number of existing repetitions.
1223 */
1224 public ADT_A06_INSURANCE getINSURANCE(int rep) {
1225 return getTyped("INSURANCE", rep, ADT_A06_INSURANCE.class);
1226 }
1227
1228 /**
1229 * <p>
1230 * Returns the number of existing repetitions of INSURANCE
1231 * </p>
1232 *
1233 */
1234 public int getINSURANCEReps() {
1235 return getReps("INSURANCE");
1236 }
1237
1238 /**
1239 * <p>
1240 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
1241 * <p>
1242 * <p>
1243 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
1244 * if none are already present, so an empty list may be returned.
1245 * </p>
1246 *
1247 */
1248 public java.util.List<ADT_A06_INSURANCE> getINSURANCEAll() throws HL7Exception {
1249 return getAllAsList("INSURANCE", ADT_A06_INSURANCE.class);
1250 }
1251
1252 /**
1253 * <p>
1254 * Inserts a specific repetition of INSURANCE (a Group object)
1255 * </p>
1256 *
1257 *
1258 * @see AbstractGroup#insertRepetition(Structure, int)
1259 */
1260 public void insertINSURANCE(ADT_A06_INSURANCE structure, int rep) throws HL7Exception {
1261 super.insertRepetition( "INSURANCE", structure, rep);
1262 }
1263
1264
1265 /**
1266 * <p>
1267 * Inserts a specific repetition of INSURANCE (a Group object)
1268 * </p>
1269 *
1270 *
1271 * @see AbstractGroup#insertRepetition(Structure, int)
1272 */
1273 public ADT_A06_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
1274 return (ADT_A06_INSURANCE)super.insertRepetition("INSURANCE", rep);
1275 }
1276
1277
1278 /**
1279 * <p>
1280 * Removes a specific repetition of INSURANCE (a Group object)
1281 * </p>
1282 *
1283 *
1284 * @see AbstractGroup#removeRepetition(String, int)
1285 */
1286 public ADT_A06_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
1287 return (ADT_A06_INSURANCE)super.removeRepetition("INSURANCE", rep);
1288 }
1289
1290
1291
1292
1293 /**
1294 * <p>
1295 * Returns
1296 * ACC (Accident) - creates it if necessary
1297 * </p>
1298 *
1299 *
1300 */
1301 public ACC getACC() {
1302 return getTyped("ACC", ACC.class);
1303 }
1304
1305
1306
1307
1308
1309 /**
1310 * <p>
1311 * Returns
1312 * UB1 (UB82) - creates it if necessary
1313 * </p>
1314 *
1315 *
1316 */
1317 public UB1 getUB1() {
1318 return getTyped("UB1", UB1.class);
1319 }
1320
1321
1322
1323
1324
1325 /**
1326 * <p>
1327 * Returns
1328 * UB2 (UB92 Data) - creates it if necessary
1329 * </p>
1330 *
1331 *
1332 */
1333 public UB2 getUB2() {
1334 return getTyped("UB2", UB2.class);
1335 }
1336
1337
1338
1339
1340 }
1341