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