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