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