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.v22.message;
35
36 import ca.uhn.hl7v2.model.v22.group.*;
37 import ca.uhn.hl7v2.model.v22.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 ?). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (MESSAGE HEADER) <b> </b> </li>
50 * <li>2: EVN (EVENT TYPE) <b> </b> </li>
51 * <li>3: PID (PATIENT IDENTIFICATION) <b> </b> </li>
52 * <li>4: NK1 (NEXT OF KIN) <b>optional repeating</b> </li>
53 * <li>5: PV1 (PATIENT VISIT) <b> </b> </li>
54 * <li>6: PV2 (PATIENT VISIT - additional information) <b>optional </b> </li>
55 * <li>7: OBX (OBSERVATION RESULT) <b>optional repeating</b> </li>
56 * <li>8: AL1 (PATIENT ALLERGY INFORMATION) <b>optional repeating</b> </li>
57 * <li>9: DG1 (DIAGNOSIS) <b>optional repeating</b> </li>
58 * <li>10: PR1 (PROCEDURES) <b>optional repeating</b> </li>
59 * <li>11: GT1 (GUARANTOR) <b>optional repeating</b> </li>
60 * <li>12: ADT_A01_INSURANCE (a Group object) <b>optional repeating</b> </li>
61 * <li>13: ACC (ACCIDENT) <b>optional </b> </li>
62 * <li>14: UB1 (UB82 DATA) <b>optional </b> </li>
63 * <li>15: UB2 (UB92 DATA) <b>optional </b> </li>
64 * </ul>
65 */
66 //@SuppressWarnings("unused")
67 public class ADT_A01 extends AbstractMessage {
68
69 /**
70 * Creates a new ADT_A01 message with DefaultModelClassFactory.
71 */
72 public ADT_A01() {
73 this(new DefaultModelClassFactory());
74 }
75
76 /**
77 * Creates a new ADT_A01 message with custom ModelClassFactory.
78 */
79 public ADT_A01(ModelClassFactory factory) {
80 super(factory);
81 init(factory);
82 }
83
84 private void init(ModelClassFactory factory) {
85 try {
86 this.add(MSH.class, true, false);
87 this.add(EVN.class, true, false);
88 this.add(PID.class, true, false);
89 this.add(NK1.class, false, true);
90 this.add(PV1.class, true, false);
91 this.add(PV2.class, false, false);
92 this.add(OBX.class, false, true);
93 this.add(AL1.class, false, true);
94 this.add(DG1.class, false, true);
95 this.add(PR1.class, false, true);
96 this.add(GT1.class, false, true);
97 this.add(ADT_A01_INSURANCE.class, false, true);
98 this.add(ACC.class, false, false);
99 this.add(UB1.class, false, false);
100 this.add(UB2.class, false, false);
101 } catch(HL7Exception e) {
102 log.error("Unexpected error creating ADT_A01 - this is probably a bug in the source code generator.", e);
103 }
104 }
105
106
107 /**
108 * Returns "2.2"
109 */
110 public String getVersion() {
111 return "2.2";
112 }
113
114
115
116
117 /**
118 * <p>
119 * Returns
120 * MSH (MESSAGE HEADER) - creates it if necessary
121 * </p>
122 *
123 *
124 */
125 public MSH getMSH() {
126 return getTyped("MSH", MSH.class);
127 }
128
129
130
131
132
133 /**
134 * <p>
135 * Returns
136 * EVN (EVENT TYPE) - creates it if necessary
137 * </p>
138 *
139 *
140 */
141 public EVN getEVN() {
142 return getTyped("EVN", EVN.class);
143 }
144
145
146
147
148
149 /**
150 * <p>
151 * Returns
152 * PID (PATIENT IDENTIFICATION) - creates it if necessary
153 * </p>
154 *
155 *
156 */
157 public PID getPID() {
158 return getTyped("PID", PID.class);
159 }
160
161
162
163
164
165 /**
166 * <p>
167 * Returns
168 * the first repetition of
169 * NK1 (NEXT OF KIN) - creates it if necessary
170 * </p>
171 *
172 *
173 */
174 public NK1 getNK1() {
175 return getTyped("NK1", NK1.class);
176 }
177
178
179 /**
180 * <p>
181 * Returns a specific repetition of
182 * NK1 (NEXT OF KIN) - creates it if necessary
183 * </p>
184 *
185 *
186 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
187 * @throws HL7Exception if the repetition requested is more than one
188 * greater than the number of existing repetitions.
189 */
190 public NK1 getNK1(int rep) {
191 return getTyped("NK1", rep, NK1.class);
192 }
193
194 /**
195 * <p>
196 * Returns the number of existing repetitions of NK1
197 * </p>
198 *
199 */
200 public int getNK1Reps() {
201 return getReps("NK1");
202 }
203
204 /**
205 * <p>
206 * Returns a non-modifiable List containing all current existing repetitions of NK1.
207 * <p>
208 * <p>
209 * Note that unlike {@link #getNK1()}, this method will not create any reps
210 * if none are already present, so an empty list may be returned.
211 * </p>
212 *
213 */
214 public java.util.List<NK1> getNK1All() throws HL7Exception {
215 return getAllAsList("NK1", NK1.class);
216 }
217
218 /**
219 * <p>
220 * Inserts a specific repetition of NK1 (NEXT OF KIN)
221 * </p>
222 *
223 *
224 * @see AbstractGroup#insertRepetition(Structure, int)
225 */
226 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
227 super.insertRepetition( "NK1", structure, rep);
228 }
229
230
231 /**
232 * <p>
233 * Inserts a specific repetition of NK1 (NEXT OF KIN)
234 * </p>
235 *
236 *
237 * @see AbstractGroup#insertRepetition(Structure, int)
238 */
239 public NK1 insertNK1(int rep) throws HL7Exception {
240 return (NK1)super.insertRepetition("NK1", rep);
241 }
242
243
244 /**
245 * <p>
246 * Removes a specific repetition of NK1 (NEXT OF KIN)
247 * </p>
248 *
249 *
250 * @see AbstractGroup#removeRepetition(String, int)
251 */
252 public NK1 removeNK1(int rep) throws HL7Exception {
253 return (NK1)super.removeRepetition("NK1", rep);
254 }
255
256
257
258
259 /**
260 * <p>
261 * Returns
262 * PV1 (PATIENT VISIT) - creates it if necessary
263 * </p>
264 *
265 *
266 */
267 public PV1 getPV1() {
268 return getTyped("PV1", PV1.class);
269 }
270
271
272
273
274
275 /**
276 * <p>
277 * Returns
278 * PV2 (PATIENT VISIT - additional information) - creates it if necessary
279 * </p>
280 *
281 *
282 */
283 public PV2 getPV2() {
284 return getTyped("PV2", PV2.class);
285 }
286
287
288
289
290
291 /**
292 * <p>
293 * Returns
294 * the first repetition of
295 * OBX (OBSERVATION RESULT) - creates it if necessary
296 * </p>
297 *
298 *
299 */
300 public OBX getOBX() {
301 return getTyped("OBX", OBX.class);
302 }
303
304
305 /**
306 * <p>
307 * Returns a specific repetition of
308 * OBX (OBSERVATION RESULT) - creates it if necessary
309 * </p>
310 *
311 *
312 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
313 * @throws HL7Exception if the repetition requested is more than one
314 * greater than the number of existing repetitions.
315 */
316 public OBX getOBX(int rep) {
317 return getTyped("OBX", rep, OBX.class);
318 }
319
320 /**
321 * <p>
322 * Returns the number of existing repetitions of OBX
323 * </p>
324 *
325 */
326 public int getOBXReps() {
327 return getReps("OBX");
328 }
329
330 /**
331 * <p>
332 * Returns a non-modifiable List containing all current existing repetitions of OBX.
333 * <p>
334 * <p>
335 * Note that unlike {@link #getOBX()}, this method will not create any reps
336 * if none are already present, so an empty list may be returned.
337 * </p>
338 *
339 */
340 public java.util.List<OBX> getOBXAll() throws HL7Exception {
341 return getAllAsList("OBX", OBX.class);
342 }
343
344 /**
345 * <p>
346 * Inserts a specific repetition of OBX (OBSERVATION RESULT)
347 * </p>
348 *
349 *
350 * @see AbstractGroup#insertRepetition(Structure, int)
351 */
352 public void insertOBX(OBX structure, int rep) throws HL7Exception {
353 super.insertRepetition( "OBX", structure, rep);
354 }
355
356
357 /**
358 * <p>
359 * Inserts a specific repetition of OBX (OBSERVATION RESULT)
360 * </p>
361 *
362 *
363 * @see AbstractGroup#insertRepetition(Structure, int)
364 */
365 public OBX insertOBX(int rep) throws HL7Exception {
366 return (OBX)super.insertRepetition("OBX", rep);
367 }
368
369
370 /**
371 * <p>
372 * Removes a specific repetition of OBX (OBSERVATION RESULT)
373 * </p>
374 *
375 *
376 * @see AbstractGroup#removeRepetition(String, int)
377 */
378 public OBX removeOBX(int rep) throws HL7Exception {
379 return (OBX)super.removeRepetition("OBX", rep);
380 }
381
382
383
384
385 /**
386 * <p>
387 * Returns
388 * the first repetition of
389 * AL1 (PATIENT ALLERGY INFORMATION) - creates it if necessary
390 * </p>
391 *
392 *
393 */
394 public AL1 getAL1() {
395 return getTyped("AL1", AL1.class);
396 }
397
398
399 /**
400 * <p>
401 * Returns a specific repetition of
402 * AL1 (PATIENT ALLERGY INFORMATION) - creates it if necessary
403 * </p>
404 *
405 *
406 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
407 * @throws HL7Exception if the repetition requested is more than one
408 * greater than the number of existing repetitions.
409 */
410 public AL1 getAL1(int rep) {
411 return getTyped("AL1", rep, AL1.class);
412 }
413
414 /**
415 * <p>
416 * Returns the number of existing repetitions of AL1
417 * </p>
418 *
419 */
420 public int getAL1Reps() {
421 return getReps("AL1");
422 }
423
424 /**
425 * <p>
426 * Returns a non-modifiable List containing all current existing repetitions of AL1.
427 * <p>
428 * <p>
429 * Note that unlike {@link #getAL1()}, this method will not create any reps
430 * if none are already present, so an empty list may be returned.
431 * </p>
432 *
433 */
434 public java.util.List<AL1> getAL1All() throws HL7Exception {
435 return getAllAsList("AL1", AL1.class);
436 }
437
438 /**
439 * <p>
440 * Inserts a specific repetition of AL1 (PATIENT ALLERGY INFORMATION)
441 * </p>
442 *
443 *
444 * @see AbstractGroup#insertRepetition(Structure, int)
445 */
446 public void insertAL1(AL1 structure, int rep) throws HL7Exception {
447 super.insertRepetition( "AL1", structure, rep);
448 }
449
450
451 /**
452 * <p>
453 * Inserts a specific repetition of AL1 (PATIENT ALLERGY INFORMATION)
454 * </p>
455 *
456 *
457 * @see AbstractGroup#insertRepetition(Structure, int)
458 */
459 public AL1 insertAL1(int rep) throws HL7Exception {
460 return (AL1)super.insertRepetition("AL1", rep);
461 }
462
463
464 /**
465 * <p>
466 * Removes a specific repetition of AL1 (PATIENT ALLERGY INFORMATION)
467 * </p>
468 *
469 *
470 * @see AbstractGroup#removeRepetition(String, int)
471 */
472 public AL1 removeAL1(int rep) throws HL7Exception {
473 return (AL1)super.removeRepetition("AL1", rep);
474 }
475
476
477
478
479 /**
480 * <p>
481 * Returns
482 * the first repetition of
483 * DG1 (DIAGNOSIS) - creates it if necessary
484 * </p>
485 *
486 *
487 */
488 public DG1 getDG1() {
489 return getTyped("DG1", DG1.class);
490 }
491
492
493 /**
494 * <p>
495 * Returns a specific repetition of
496 * DG1 (DIAGNOSIS) - creates it if necessary
497 * </p>
498 *
499 *
500 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
501 * @throws HL7Exception if the repetition requested is more than one
502 * greater than the number of existing repetitions.
503 */
504 public DG1 getDG1(int rep) {
505 return getTyped("DG1", rep, DG1.class);
506 }
507
508 /**
509 * <p>
510 * Returns the number of existing repetitions of DG1
511 * </p>
512 *
513 */
514 public int getDG1Reps() {
515 return getReps("DG1");
516 }
517
518 /**
519 * <p>
520 * Returns a non-modifiable List containing all current existing repetitions of DG1.
521 * <p>
522 * <p>
523 * Note that unlike {@link #getDG1()}, this method will not create any reps
524 * if none are already present, so an empty list may be returned.
525 * </p>
526 *
527 */
528 public java.util.List<DG1> getDG1All() throws HL7Exception {
529 return getAllAsList("DG1", DG1.class);
530 }
531
532 /**
533 * <p>
534 * Inserts a specific repetition of DG1 (DIAGNOSIS)
535 * </p>
536 *
537 *
538 * @see AbstractGroup#insertRepetition(Structure, int)
539 */
540 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
541 super.insertRepetition( "DG1", structure, rep);
542 }
543
544
545 /**
546 * <p>
547 * Inserts a specific repetition of DG1 (DIAGNOSIS)
548 * </p>
549 *
550 *
551 * @see AbstractGroup#insertRepetition(Structure, int)
552 */
553 public DG1 insertDG1(int rep) throws HL7Exception {
554 return (DG1)super.insertRepetition("DG1", rep);
555 }
556
557
558 /**
559 * <p>
560 * Removes a specific repetition of DG1 (DIAGNOSIS)
561 * </p>
562 *
563 *
564 * @see AbstractGroup#removeRepetition(String, int)
565 */
566 public DG1 removeDG1(int rep) throws HL7Exception {
567 return (DG1)super.removeRepetition("DG1", rep);
568 }
569
570
571
572
573 /**
574 * <p>
575 * Returns
576 * the first repetition of
577 * PR1 (PROCEDURES) - creates it if necessary
578 * </p>
579 *
580 *
581 */
582 public PR1 getPR1() {
583 return getTyped("PR1", PR1.class);
584 }
585
586
587 /**
588 * <p>
589 * Returns a specific repetition of
590 * PR1 (PROCEDURES) - creates it if necessary
591 * </p>
592 *
593 *
594 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
595 * @throws HL7Exception if the repetition requested is more than one
596 * greater than the number of existing repetitions.
597 */
598 public PR1 getPR1(int rep) {
599 return getTyped("PR1", rep, PR1.class);
600 }
601
602 /**
603 * <p>
604 * Returns the number of existing repetitions of PR1
605 * </p>
606 *
607 */
608 public int getPR1Reps() {
609 return getReps("PR1");
610 }
611
612 /**
613 * <p>
614 * Returns a non-modifiable List containing all current existing repetitions of PR1.
615 * <p>
616 * <p>
617 * Note that unlike {@link #getPR1()}, this method will not create any reps
618 * if none are already present, so an empty list may be returned.
619 * </p>
620 *
621 */
622 public java.util.List<PR1> getPR1All() throws HL7Exception {
623 return getAllAsList("PR1", PR1.class);
624 }
625
626 /**
627 * <p>
628 * Inserts a specific repetition of PR1 (PROCEDURES)
629 * </p>
630 *
631 *
632 * @see AbstractGroup#insertRepetition(Structure, int)
633 */
634 public void insertPR1(PR1 structure, int rep) throws HL7Exception {
635 super.insertRepetition( "PR1", structure, rep);
636 }
637
638
639 /**
640 * <p>
641 * Inserts a specific repetition of PR1 (PROCEDURES)
642 * </p>
643 *
644 *
645 * @see AbstractGroup#insertRepetition(Structure, int)
646 */
647 public PR1 insertPR1(int rep) throws HL7Exception {
648 return (PR1)super.insertRepetition("PR1", rep);
649 }
650
651
652 /**
653 * <p>
654 * Removes a specific repetition of PR1 (PROCEDURES)
655 * </p>
656 *
657 *
658 * @see AbstractGroup#removeRepetition(String, int)
659 */
660 public PR1 removePR1(int rep) throws HL7Exception {
661 return (PR1)super.removeRepetition("PR1", rep);
662 }
663
664
665
666
667 /**
668 * <p>
669 * Returns
670 * the first repetition of
671 * GT1 (GUARANTOR) - creates it if necessary
672 * </p>
673 *
674 *
675 */
676 public GT1 getGT1() {
677 return getTyped("GT1", GT1.class);
678 }
679
680
681 /**
682 * <p>
683 * Returns a specific repetition of
684 * GT1 (GUARANTOR) - creates it if necessary
685 * </p>
686 *
687 *
688 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
689 * @throws HL7Exception if the repetition requested is more than one
690 * greater than the number of existing repetitions.
691 */
692 public GT1 getGT1(int rep) {
693 return getTyped("GT1", rep, GT1.class);
694 }
695
696 /**
697 * <p>
698 * Returns the number of existing repetitions of GT1
699 * </p>
700 *
701 */
702 public int getGT1Reps() {
703 return getReps("GT1");
704 }
705
706 /**
707 * <p>
708 * Returns a non-modifiable List containing all current existing repetitions of GT1.
709 * <p>
710 * <p>
711 * Note that unlike {@link #getGT1()}, this method will not create any reps
712 * if none are already present, so an empty list may be returned.
713 * </p>
714 *
715 */
716 public java.util.List<GT1> getGT1All() throws HL7Exception {
717 return getAllAsList("GT1", GT1.class);
718 }
719
720 /**
721 * <p>
722 * Inserts a specific repetition of GT1 (GUARANTOR)
723 * </p>
724 *
725 *
726 * @see AbstractGroup#insertRepetition(Structure, int)
727 */
728 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
729 super.insertRepetition( "GT1", structure, rep);
730 }
731
732
733 /**
734 * <p>
735 * Inserts a specific repetition of GT1 (GUARANTOR)
736 * </p>
737 *
738 *
739 * @see AbstractGroup#insertRepetition(Structure, int)
740 */
741 public GT1 insertGT1(int rep) throws HL7Exception {
742 return (GT1)super.insertRepetition("GT1", rep);
743 }
744
745
746 /**
747 * <p>
748 * Removes a specific repetition of GT1 (GUARANTOR)
749 * </p>
750 *
751 *
752 * @see AbstractGroup#removeRepetition(String, int)
753 */
754 public GT1 removeGT1(int rep) throws HL7Exception {
755 return (GT1)super.removeRepetition("GT1", rep);
756 }
757
758
759
760
761 /**
762 * <p>
763 * Returns
764 * the first repetition of
765 * INSURANCE (a Group object) - creates it if necessary
766 * </p>
767 *
768 *
769 */
770 public ADT_A01_INSURANCE getINSURANCE() {
771 return getTyped("INSURANCE", ADT_A01_INSURANCE.class);
772 }
773
774
775 /**
776 * <p>
777 * Returns a specific repetition of
778 * INSURANCE (a Group object) - creates it if necessary
779 * </p>
780 *
781 *
782 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
783 * @throws HL7Exception if the repetition requested is more than one
784 * greater than the number of existing repetitions.
785 */
786 public ADT_A01_INSURANCE getINSURANCE(int rep) {
787 return getTyped("INSURANCE", rep, ADT_A01_INSURANCE.class);
788 }
789
790 /**
791 * <p>
792 * Returns the number of existing repetitions of INSURANCE
793 * </p>
794 *
795 */
796 public int getINSURANCEReps() {
797 return getReps("INSURANCE");
798 }
799
800 /**
801 * <p>
802 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
803 * <p>
804 * <p>
805 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
806 * if none are already present, so an empty list may be returned.
807 * </p>
808 *
809 */
810 public java.util.List<ADT_A01_INSURANCE> getINSURANCEAll() throws HL7Exception {
811 return getAllAsList("INSURANCE", ADT_A01_INSURANCE.class);
812 }
813
814 /**
815 * <p>
816 * Inserts a specific repetition of INSURANCE (a Group object)
817 * </p>
818 *
819 *
820 * @see AbstractGroup#insertRepetition(Structure, int)
821 */
822 public void insertINSURANCE(ADT_A01_INSURANCE structure, int rep) throws HL7Exception {
823 super.insertRepetition( "INSURANCE", structure, rep);
824 }
825
826
827 /**
828 * <p>
829 * Inserts a specific repetition of INSURANCE (a Group object)
830 * </p>
831 *
832 *
833 * @see AbstractGroup#insertRepetition(Structure, int)
834 */
835 public ADT_A01_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
836 return (ADT_A01_INSURANCE)super.insertRepetition("INSURANCE", rep);
837 }
838
839
840 /**
841 * <p>
842 * Removes a specific repetition of INSURANCE (a Group object)
843 * </p>
844 *
845 *
846 * @see AbstractGroup#removeRepetition(String, int)
847 */
848 public ADT_A01_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
849 return (ADT_A01_INSURANCE)super.removeRepetition("INSURANCE", rep);
850 }
851
852
853
854
855 /**
856 * <p>
857 * Returns
858 * ACC (ACCIDENT) - creates it if necessary
859 * </p>
860 *
861 *
862 */
863 public ACC getACC() {
864 return getTyped("ACC", ACC.class);
865 }
866
867
868
869
870
871 /**
872 * <p>
873 * Returns
874 * UB1 (UB82 DATA) - creates it if necessary
875 * </p>
876 *
877 *
878 */
879 public UB1 getUB1() {
880 return getTyped("UB1", UB1.class);
881 }
882
883
884
885
886
887 /**
888 * <p>
889 * Returns
890 * UB2 (UB92 DATA) - creates it if necessary
891 * </p>
892 *
893 *
894 */
895 public UB2 getUB2() {
896 return getTyped("UB2", UB2.class);
897 }
898
899
900
901
902 }
903