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