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