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.v25.message;
35
36 import ca.uhn.hl7v2.model.v25.group.*;
37 import ca.uhn.hl7v2.model.v25.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_A01 message structure (see chapter 3.3.1). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (Message Header) <b> </b> </li>
50 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li>
51 * <li>3: 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: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li>
56 * <li>8: PV1 (Patient Visit) <b> </b> </li>
57 * <li>9: PV2 (Patient Visit - Additional Information) <b>optional </b> </li>
58 * <li>10: ROL (Role) <b>optional repeating</b> </li>
59 * <li>11: DB1 (Disability) <b>optional repeating</b> </li>
60 * <li>12: OBX (Observation/Result) <b>optional repeating</b> </li>
61 * <li>13: AL1 (Patient Allergy Information) <b>optional repeating</b> </li>
62 * <li>14: DG1 (Diagnosis) <b>optional repeating</b> </li>
63 * <li>15: DRG (Diagnosis Related Group) <b>optional </b> </li>
64 * <li>16: ADT_A01_PROCEDURE (a Group object) <b>optional repeating</b> </li>
65 * <li>17: GT1 (Guarantor) <b>optional repeating</b> </li>
66 * <li>18: ADT_A01_INSURANCE (a Group object) <b>optional repeating</b> </li>
67 * <li>19: ACC (Accident) <b>optional </b> </li>
68 * <li>20: UB1 (UB82) <b>optional </b> </li>
69 * <li>21: UB2 (UB92 Data) <b>optional </b> </li>
70 * <li>22: PDA (Patient Death and Autopsy) <b>optional </b> </li>
71 * </ul>
72 */
73 //@SuppressWarnings("unused")
74 public class ADT_A01 extends AbstractMessage {
75
76 /**
77 * Creates a new ADT_A01 message with DefaultModelClassFactory.
78 */
79 public ADT_A01() {
80 this(new DefaultModelClassFactory());
81 }
82
83 /**
84 * Creates a new ADT_A01 message with custom ModelClassFactory.
85 */
86 public ADT_A01(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(NK1.class, false, true);
100 this.add(PV1.class, true, false);
101 this.add(PV2.class, false, false);
102 this.add(ROL.class, false, true);
103 this.add(DB1.class, false, true);
104 this.add(OBX.class, false, true);
105 this.add(AL1.class, false, true);
106 this.add(DG1.class, false, true);
107 this.add(DRG.class, false, false);
108 this.add(ADT_A01_PROCEDURE.class, false, true);
109 this.add(GT1.class, false, true);
110 this.add(ADT_A01_INSURANCE.class, false, true);
111 this.add(ACC.class, false, false);
112 this.add(UB1.class, false, false);
113 this.add(UB2.class, false, false);
114 this.add(PDA.class, false, false);
115 } catch(HL7Exception e) {
116 log.error("Unexpected error creating ADT_A01 - this is probably a bug in the source code generator.", e);
117 }
118 }
119
120
121 /**
122 * Returns "2.5"
123 */
124 public String getVersion() {
125 return "2.5";
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 * the first repetition of
387 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
388 * </p>
389 *
390 *
391 */
392 public NK1 getNK1() {
393 return getTyped("NK1", NK1.class);
394 }
395
396
397 /**
398 * <p>
399 * Returns a specific repetition of
400 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
401 * </p>
402 *
403 *
404 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
405 * @throws HL7Exception if the repetition requested is more than one
406 * greater than the number of existing repetitions.
407 */
408 public NK1 getNK1(int rep) {
409 return getTyped("NK1", rep, NK1.class);
410 }
411
412 /**
413 * <p>
414 * Returns the number of existing repetitions of NK1
415 * </p>
416 *
417 */
418 public int getNK1Reps() {
419 return getReps("NK1");
420 }
421
422 /**
423 * <p>
424 * Returns a non-modifiable List containing all current existing repetitions of NK1.
425 * <p>
426 * <p>
427 * Note that unlike {@link #getNK1()}, this method will not create any reps
428 * if none are already present, so an empty list may be returned.
429 * </p>
430 *
431 */
432 public java.util.List<NK1> getNK1All() throws HL7Exception {
433 return getAllAsList("NK1", NK1.class);
434 }
435
436 /**
437 * <p>
438 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
439 * </p>
440 *
441 *
442 * @see AbstractGroup#insertRepetition(Structure, int)
443 */
444 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
445 super.insertRepetition( "NK1", structure, rep);
446 }
447
448
449 /**
450 * <p>
451 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
452 * </p>
453 *
454 *
455 * @see AbstractGroup#insertRepetition(Structure, int)
456 */
457 public NK1 insertNK1(int rep) throws HL7Exception {
458 return (NK1)super.insertRepetition("NK1", rep);
459 }
460
461
462 /**
463 * <p>
464 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties)
465 * </p>
466 *
467 *
468 * @see AbstractGroup#removeRepetition(String, int)
469 */
470 public NK1 removeNK1(int rep) throws HL7Exception {
471 return (NK1)super.removeRepetition("NK1", rep);
472 }
473
474
475
476
477 /**
478 * <p>
479 * Returns
480 * PV1 (Patient Visit) - creates it if necessary
481 * </p>
482 *
483 *
484 */
485 public PV1 getPV1() {
486 return getTyped("PV1", PV1.class);
487 }
488
489
490
491
492
493 /**
494 * <p>
495 * Returns
496 * PV2 (Patient Visit - Additional Information) - creates it if necessary
497 * </p>
498 *
499 *
500 */
501 public PV2 getPV2() {
502 return getTyped("PV2", PV2.class);
503 }
504
505
506
507
508
509 /**
510 * <p>
511 * Returns
512 * the first repetition of
513 * ROL2 (Role) - creates it if necessary
514 * </p>
515 *
516 *
517 */
518 public ROL getROL2() {
519 return getTyped("ROL2", ROL.class);
520 }
521
522
523 /**
524 * <p>
525 * Returns a specific repetition of
526 * ROL2 (Role) - creates it if necessary
527 * </p>
528 *
529 *
530 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
531 * @throws HL7Exception if the repetition requested is more than one
532 * greater than the number of existing repetitions.
533 */
534 public ROL getROL2(int rep) {
535 return getTyped("ROL2", rep, ROL.class);
536 }
537
538 /**
539 * <p>
540 * Returns the number of existing repetitions of ROL2
541 * </p>
542 *
543 */
544 public int getROL2Reps() {
545 return getReps("ROL2");
546 }
547
548 /**
549 * <p>
550 * Returns a non-modifiable List containing all current existing repetitions of ROL2.
551 * <p>
552 * <p>
553 * Note that unlike {@link #getROL2()}, this method will not create any reps
554 * if none are already present, so an empty list may be returned.
555 * </p>
556 *
557 */
558 public java.util.List<ROL> getROL2All() throws HL7Exception {
559 return getAllAsList("ROL2", ROL.class);
560 }
561
562 /**
563 * <p>
564 * Inserts a specific repetition of ROL2 (Role)
565 * </p>
566 *
567 *
568 * @see AbstractGroup#insertRepetition(Structure, int)
569 */
570 public void insertROL2(ROL structure, int rep) throws HL7Exception {
571 super.insertRepetition( "ROL2", structure, rep);
572 }
573
574
575 /**
576 * <p>
577 * Inserts a specific repetition of ROL2 (Role)
578 * </p>
579 *
580 *
581 * @see AbstractGroup#insertRepetition(Structure, int)
582 */
583 public ROL insertROL2(int rep) throws HL7Exception {
584 return (ROL)super.insertRepetition("ROL2", rep);
585 }
586
587
588 /**
589 * <p>
590 * Removes a specific repetition of ROL2 (Role)
591 * </p>
592 *
593 *
594 * @see AbstractGroup#removeRepetition(String, int)
595 */
596 public ROL removeROL2(int rep) throws HL7Exception {
597 return (ROL)super.removeRepetition("ROL2", rep);
598 }
599
600
601
602
603 /**
604 * <p>
605 * Returns
606 * the first repetition of
607 * DB1 (Disability) - creates it if necessary
608 * </p>
609 *
610 *
611 */
612 public DB1 getDB1() {
613 return getTyped("DB1", DB1.class);
614 }
615
616
617 /**
618 * <p>
619 * Returns a specific repetition of
620 * DB1 (Disability) - creates it if necessary
621 * </p>
622 *
623 *
624 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
625 * @throws HL7Exception if the repetition requested is more than one
626 * greater than the number of existing repetitions.
627 */
628 public DB1 getDB1(int rep) {
629 return getTyped("DB1", rep, DB1.class);
630 }
631
632 /**
633 * <p>
634 * Returns the number of existing repetitions of DB1
635 * </p>
636 *
637 */
638 public int getDB1Reps() {
639 return getReps("DB1");
640 }
641
642 /**
643 * <p>
644 * Returns a non-modifiable List containing all current existing repetitions of DB1.
645 * <p>
646 * <p>
647 * Note that unlike {@link #getDB1()}, this method will not create any reps
648 * if none are already present, so an empty list may be returned.
649 * </p>
650 *
651 */
652 public java.util.List<DB1> getDB1All() throws HL7Exception {
653 return getAllAsList("DB1", DB1.class);
654 }
655
656 /**
657 * <p>
658 * Inserts a specific repetition of DB1 (Disability)
659 * </p>
660 *
661 *
662 * @see AbstractGroup#insertRepetition(Structure, int)
663 */
664 public void insertDB1(DB1 structure, int rep) throws HL7Exception {
665 super.insertRepetition( "DB1", structure, rep);
666 }
667
668
669 /**
670 * <p>
671 * Inserts a specific repetition of DB1 (Disability)
672 * </p>
673 *
674 *
675 * @see AbstractGroup#insertRepetition(Structure, int)
676 */
677 public DB1 insertDB1(int rep) throws HL7Exception {
678 return (DB1)super.insertRepetition("DB1", rep);
679 }
680
681
682 /**
683 * <p>
684 * Removes a specific repetition of DB1 (Disability)
685 * </p>
686 *
687 *
688 * @see AbstractGroup#removeRepetition(String, int)
689 */
690 public DB1 removeDB1(int rep) throws HL7Exception {
691 return (DB1)super.removeRepetition("DB1", rep);
692 }
693
694
695
696
697 /**
698 * <p>
699 * Returns
700 * the first repetition of
701 * OBX (Observation/Result) - creates it if necessary
702 * </p>
703 *
704 *
705 */
706 public OBX getOBX() {
707 return getTyped("OBX", OBX.class);
708 }
709
710
711 /**
712 * <p>
713 * Returns a specific repetition of
714 * OBX (Observation/Result) - creates it if necessary
715 * </p>
716 *
717 *
718 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
719 * @throws HL7Exception if the repetition requested is more than one
720 * greater than the number of existing repetitions.
721 */
722 public OBX getOBX(int rep) {
723 return getTyped("OBX", rep, OBX.class);
724 }
725
726 /**
727 * <p>
728 * Returns the number of existing repetitions of OBX
729 * </p>
730 *
731 */
732 public int getOBXReps() {
733 return getReps("OBX");
734 }
735
736 /**
737 * <p>
738 * Returns a non-modifiable List containing all current existing repetitions of OBX.
739 * <p>
740 * <p>
741 * Note that unlike {@link #getOBX()}, this method will not create any reps
742 * if none are already present, so an empty list may be returned.
743 * </p>
744 *
745 */
746 public java.util.List<OBX> getOBXAll() throws HL7Exception {
747 return getAllAsList("OBX", OBX.class);
748 }
749
750 /**
751 * <p>
752 * Inserts a specific repetition of OBX (Observation/Result)
753 * </p>
754 *
755 *
756 * @see AbstractGroup#insertRepetition(Structure, int)
757 */
758 public void insertOBX(OBX structure, int rep) throws HL7Exception {
759 super.insertRepetition( "OBX", structure, rep);
760 }
761
762
763 /**
764 * <p>
765 * Inserts a specific repetition of OBX (Observation/Result)
766 * </p>
767 *
768 *
769 * @see AbstractGroup#insertRepetition(Structure, int)
770 */
771 public OBX insertOBX(int rep) throws HL7Exception {
772 return (OBX)super.insertRepetition("OBX", rep);
773 }
774
775
776 /**
777 * <p>
778 * Removes a specific repetition of OBX (Observation/Result)
779 * </p>
780 *
781 *
782 * @see AbstractGroup#removeRepetition(String, int)
783 */
784 public OBX removeOBX(int rep) throws HL7Exception {
785 return (OBX)super.removeRepetition("OBX", rep);
786 }
787
788
789
790
791 /**
792 * <p>
793 * Returns
794 * the first repetition of
795 * AL1 (Patient Allergy Information) - creates it if necessary
796 * </p>
797 *
798 *
799 */
800 public AL1 getAL1() {
801 return getTyped("AL1", AL1.class);
802 }
803
804
805 /**
806 * <p>
807 * Returns a specific repetition of
808 * AL1 (Patient Allergy Information) - creates it if necessary
809 * </p>
810 *
811 *
812 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
813 * @throws HL7Exception if the repetition requested is more than one
814 * greater than the number of existing repetitions.
815 */
816 public AL1 getAL1(int rep) {
817 return getTyped("AL1", rep, AL1.class);
818 }
819
820 /**
821 * <p>
822 * Returns the number of existing repetitions of AL1
823 * </p>
824 *
825 */
826 public int getAL1Reps() {
827 return getReps("AL1");
828 }
829
830 /**
831 * <p>
832 * Returns a non-modifiable List containing all current existing repetitions of AL1.
833 * <p>
834 * <p>
835 * Note that unlike {@link #getAL1()}, this method will not create any reps
836 * if none are already present, so an empty list may be returned.
837 * </p>
838 *
839 */
840 public java.util.List<AL1> getAL1All() throws HL7Exception {
841 return getAllAsList("AL1", AL1.class);
842 }
843
844 /**
845 * <p>
846 * Inserts a specific repetition of AL1 (Patient Allergy Information)
847 * </p>
848 *
849 *
850 * @see AbstractGroup#insertRepetition(Structure, int)
851 */
852 public void insertAL1(AL1 structure, int rep) throws HL7Exception {
853 super.insertRepetition( "AL1", structure, rep);
854 }
855
856
857 /**
858 * <p>
859 * Inserts a specific repetition of AL1 (Patient Allergy Information)
860 * </p>
861 *
862 *
863 * @see AbstractGroup#insertRepetition(Structure, int)
864 */
865 public AL1 insertAL1(int rep) throws HL7Exception {
866 return (AL1)super.insertRepetition("AL1", rep);
867 }
868
869
870 /**
871 * <p>
872 * Removes a specific repetition of AL1 (Patient Allergy Information)
873 * </p>
874 *
875 *
876 * @see AbstractGroup#removeRepetition(String, int)
877 */
878 public AL1 removeAL1(int rep) throws HL7Exception {
879 return (AL1)super.removeRepetition("AL1", rep);
880 }
881
882
883
884
885 /**
886 * <p>
887 * Returns
888 * the first repetition of
889 * DG1 (Diagnosis) - creates it if necessary
890 * </p>
891 *
892 *
893 */
894 public DG1 getDG1() {
895 return getTyped("DG1", DG1.class);
896 }
897
898
899 /**
900 * <p>
901 * Returns a specific repetition of
902 * DG1 (Diagnosis) - creates it if necessary
903 * </p>
904 *
905 *
906 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
907 * @throws HL7Exception if the repetition requested is more than one
908 * greater than the number of existing repetitions.
909 */
910 public DG1 getDG1(int rep) {
911 return getTyped("DG1", rep, DG1.class);
912 }
913
914 /**
915 * <p>
916 * Returns the number of existing repetitions of DG1
917 * </p>
918 *
919 */
920 public int getDG1Reps() {
921 return getReps("DG1");
922 }
923
924 /**
925 * <p>
926 * Returns a non-modifiable List containing all current existing repetitions of DG1.
927 * <p>
928 * <p>
929 * Note that unlike {@link #getDG1()}, this method will not create any reps
930 * if none are already present, so an empty list may be returned.
931 * </p>
932 *
933 */
934 public java.util.List<DG1> getDG1All() throws HL7Exception {
935 return getAllAsList("DG1", DG1.class);
936 }
937
938 /**
939 * <p>
940 * Inserts a specific repetition of DG1 (Diagnosis)
941 * </p>
942 *
943 *
944 * @see AbstractGroup#insertRepetition(Structure, int)
945 */
946 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
947 super.insertRepetition( "DG1", structure, rep);
948 }
949
950
951 /**
952 * <p>
953 * Inserts a specific repetition of DG1 (Diagnosis)
954 * </p>
955 *
956 *
957 * @see AbstractGroup#insertRepetition(Structure, int)
958 */
959 public DG1 insertDG1(int rep) throws HL7Exception {
960 return (DG1)super.insertRepetition("DG1", rep);
961 }
962
963
964 /**
965 * <p>
966 * Removes a specific repetition of DG1 (Diagnosis)
967 * </p>
968 *
969 *
970 * @see AbstractGroup#removeRepetition(String, int)
971 */
972 public DG1 removeDG1(int rep) throws HL7Exception {
973 return (DG1)super.removeRepetition("DG1", rep);
974 }
975
976
977
978
979 /**
980 * <p>
981 * Returns
982 * DRG (Diagnosis Related Group) - creates it if necessary
983 * </p>
984 *
985 *
986 */
987 public DRG getDRG() {
988 return getTyped("DRG", DRG.class);
989 }
990
991
992
993
994
995 /**
996 * <p>
997 * Returns
998 * the first repetition of
999 * PROCEDURE (a Group object) - creates it if necessary
1000 * </p>
1001 *
1002 *
1003 */
1004 public ADT_A01_PROCEDURE getPROCEDURE() {
1005 return getTyped("PROCEDURE", ADT_A01_PROCEDURE.class);
1006 }
1007
1008
1009 /**
1010 * <p>
1011 * Returns a specific repetition of
1012 * PROCEDURE (a Group object) - creates it if necessary
1013 * </p>
1014 *
1015 *
1016 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1017 * @throws HL7Exception if the repetition requested is more than one
1018 * greater than the number of existing repetitions.
1019 */
1020 public ADT_A01_PROCEDURE getPROCEDURE(int rep) {
1021 return getTyped("PROCEDURE", rep, ADT_A01_PROCEDURE.class);
1022 }
1023
1024 /**
1025 * <p>
1026 * Returns the number of existing repetitions of PROCEDURE
1027 * </p>
1028 *
1029 */
1030 public int getPROCEDUREReps() {
1031 return getReps("PROCEDURE");
1032 }
1033
1034 /**
1035 * <p>
1036 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE.
1037 * <p>
1038 * <p>
1039 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps
1040 * if none are already present, so an empty list may be returned.
1041 * </p>
1042 *
1043 */
1044 public java.util.List<ADT_A01_PROCEDURE> getPROCEDUREAll() throws HL7Exception {
1045 return getAllAsList("PROCEDURE", ADT_A01_PROCEDURE.class);
1046 }
1047
1048 /**
1049 * <p>
1050 * Inserts a specific repetition of PROCEDURE (a Group object)
1051 * </p>
1052 *
1053 *
1054 * @see AbstractGroup#insertRepetition(Structure, int)
1055 */
1056 public void insertPROCEDURE(ADT_A01_PROCEDURE structure, int rep) throws HL7Exception {
1057 super.insertRepetition( "PROCEDURE", structure, rep);
1058 }
1059
1060
1061 /**
1062 * <p>
1063 * Inserts a specific repetition of PROCEDURE (a Group object)
1064 * </p>
1065 *
1066 *
1067 * @see AbstractGroup#insertRepetition(Structure, int)
1068 */
1069 public ADT_A01_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception {
1070 return (ADT_A01_PROCEDURE)super.insertRepetition("PROCEDURE", rep);
1071 }
1072
1073
1074 /**
1075 * <p>
1076 * Removes a specific repetition of PROCEDURE (a Group object)
1077 * </p>
1078 *
1079 *
1080 * @see AbstractGroup#removeRepetition(String, int)
1081 */
1082 public ADT_A01_PROCEDURE removePROCEDURE(int rep) throws HL7Exception {
1083 return (ADT_A01_PROCEDURE)super.removeRepetition("PROCEDURE", rep);
1084 }
1085
1086
1087
1088
1089 /**
1090 * <p>
1091 * Returns
1092 * the first repetition of
1093 * GT1 (Guarantor) - creates it if necessary
1094 * </p>
1095 *
1096 *
1097 */
1098 public GT1 getGT1() {
1099 return getTyped("GT1", GT1.class);
1100 }
1101
1102
1103 /**
1104 * <p>
1105 * Returns a specific repetition of
1106 * GT1 (Guarantor) - creates it if necessary
1107 * </p>
1108 *
1109 *
1110 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1111 * @throws HL7Exception if the repetition requested is more than one
1112 * greater than the number of existing repetitions.
1113 */
1114 public GT1 getGT1(int rep) {
1115 return getTyped("GT1", rep, GT1.class);
1116 }
1117
1118 /**
1119 * <p>
1120 * Returns the number of existing repetitions of GT1
1121 * </p>
1122 *
1123 */
1124 public int getGT1Reps() {
1125 return getReps("GT1");
1126 }
1127
1128 /**
1129 * <p>
1130 * Returns a non-modifiable List containing all current existing repetitions of GT1.
1131 * <p>
1132 * <p>
1133 * Note that unlike {@link #getGT1()}, this method will not create any reps
1134 * if none are already present, so an empty list may be returned.
1135 * </p>
1136 *
1137 */
1138 public java.util.List<GT1> getGT1All() throws HL7Exception {
1139 return getAllAsList("GT1", GT1.class);
1140 }
1141
1142 /**
1143 * <p>
1144 * Inserts a specific repetition of GT1 (Guarantor)
1145 * </p>
1146 *
1147 *
1148 * @see AbstractGroup#insertRepetition(Structure, int)
1149 */
1150 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
1151 super.insertRepetition( "GT1", structure, rep);
1152 }
1153
1154
1155 /**
1156 * <p>
1157 * Inserts a specific repetition of GT1 (Guarantor)
1158 * </p>
1159 *
1160 *
1161 * @see AbstractGroup#insertRepetition(Structure, int)
1162 */
1163 public GT1 insertGT1(int rep) throws HL7Exception {
1164 return (GT1)super.insertRepetition("GT1", rep);
1165 }
1166
1167
1168 /**
1169 * <p>
1170 * Removes a specific repetition of GT1 (Guarantor)
1171 * </p>
1172 *
1173 *
1174 * @see AbstractGroup#removeRepetition(String, int)
1175 */
1176 public GT1 removeGT1(int rep) throws HL7Exception {
1177 return (GT1)super.removeRepetition("GT1", rep);
1178 }
1179
1180
1181
1182
1183 /**
1184 * <p>
1185 * Returns
1186 * the first repetition of
1187 * INSURANCE (a Group object) - creates it if necessary
1188 * </p>
1189 *
1190 *
1191 */
1192 public ADT_A01_INSURANCE getINSURANCE() {
1193 return getTyped("INSURANCE", ADT_A01_INSURANCE.class);
1194 }
1195
1196
1197 /**
1198 * <p>
1199 * Returns a specific repetition of
1200 * INSURANCE (a Group object) - creates it if necessary
1201 * </p>
1202 *
1203 *
1204 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1205 * @throws HL7Exception if the repetition requested is more than one
1206 * greater than the number of existing repetitions.
1207 */
1208 public ADT_A01_INSURANCE getINSURANCE(int rep) {
1209 return getTyped("INSURANCE", rep, ADT_A01_INSURANCE.class);
1210 }
1211
1212 /**
1213 * <p>
1214 * Returns the number of existing repetitions of INSURANCE
1215 * </p>
1216 *
1217 */
1218 public int getINSURANCEReps() {
1219 return getReps("INSURANCE");
1220 }
1221
1222 /**
1223 * <p>
1224 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
1225 * <p>
1226 * <p>
1227 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
1228 * if none are already present, so an empty list may be returned.
1229 * </p>
1230 *
1231 */
1232 public java.util.List<ADT_A01_INSURANCE> getINSURANCEAll() throws HL7Exception {
1233 return getAllAsList("INSURANCE", ADT_A01_INSURANCE.class);
1234 }
1235
1236 /**
1237 * <p>
1238 * Inserts a specific repetition of INSURANCE (a Group object)
1239 * </p>
1240 *
1241 *
1242 * @see AbstractGroup#insertRepetition(Structure, int)
1243 */
1244 public void insertINSURANCE(ADT_A01_INSURANCE structure, int rep) throws HL7Exception {
1245 super.insertRepetition( "INSURANCE", structure, rep);
1246 }
1247
1248
1249 /**
1250 * <p>
1251 * Inserts a specific repetition of INSURANCE (a Group object)
1252 * </p>
1253 *
1254 *
1255 * @see AbstractGroup#insertRepetition(Structure, int)
1256 */
1257 public ADT_A01_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
1258 return (ADT_A01_INSURANCE)super.insertRepetition("INSURANCE", rep);
1259 }
1260
1261
1262 /**
1263 * <p>
1264 * Removes a specific repetition of INSURANCE (a Group object)
1265 * </p>
1266 *
1267 *
1268 * @see AbstractGroup#removeRepetition(String, int)
1269 */
1270 public ADT_A01_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
1271 return (ADT_A01_INSURANCE)super.removeRepetition("INSURANCE", rep);
1272 }
1273
1274
1275
1276
1277 /**
1278 * <p>
1279 * Returns
1280 * ACC (Accident) - creates it if necessary
1281 * </p>
1282 *
1283 *
1284 */
1285 public ACC getACC() {
1286 return getTyped("ACC", ACC.class);
1287 }
1288
1289
1290
1291
1292
1293 /**
1294 * <p>
1295 * Returns
1296 * UB1 (UB82) - creates it if necessary
1297 * </p>
1298 *
1299 *
1300 */
1301 public UB1 getUB1() {
1302 return getTyped("UB1", UB1.class);
1303 }
1304
1305
1306
1307
1308
1309 /**
1310 * <p>
1311 * Returns
1312 * UB2 (UB92 Data) - creates it if necessary
1313 * </p>
1314 *
1315 *
1316 */
1317 public UB2 getUB2() {
1318 return getTyped("UB2", UB2.class);
1319 }
1320
1321
1322
1323
1324
1325 /**
1326 * <p>
1327 * Returns
1328 * PDA (Patient Death and Autopsy) - creates it if necessary
1329 * </p>
1330 *
1331 *
1332 */
1333 public PDA getPDA() {
1334 return getTyped("PDA", PDA.class);
1335 }
1336
1337
1338
1339
1340 }
1341