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