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