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