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.v281.message;
35
36 import ca.uhn.hl7v2.model.v281.group.*;
37 import ca.uhn.hl7v2.model.v281.segment.*;
38
39 import ca.uhn.hl7v2.HL7Exception;
40 import ca.uhn.hl7v2.parser.ModelClassFactory;
41 import ca.uhn.hl7v2.parser.DefaultModelClassFactory;
42 import ca.uhn.hl7v2.model.*;
43
44
45 /**
46 * <p>Represents a REF_I12 message structure (see chapter 11.5.1). This structure contains the
47 * following elements: </p>
48 * <ul>
49 * <li>1: MSH (Message Header) <b> </b> </li>
50 * <li>2: SFT (Software Segment) <b>optional repeating</b> </li>
51 * <li>3: UAC (User Authentication Credential Segment) <b>optional </b> </li>
52 * <li>4: RF1 (Referral Information) <b>optional </b> </li>
53 * <li>5: REF_I12_AUTHORIZATION_CONTACT2 (a Group object) <b>optional </b> </li>
54 * <li>6: REF_I12_PROVIDER_CONTACT (a Group object) <b> repeating</b> </li>
55 * <li>7: PID (Patient Identification) <b> </b> </li>
56 * <li>8: NK1 (Next of Kin / Associated Parties) <b>optional repeating</b> </li>
57 * <li>9: GT1 (Guarantor) <b>optional repeating</b> </li>
58 * <li>10: REF_I12_INSURANCE (a Group object) <b>optional repeating</b> </li>
59 * <li>11: ACC (Accident) <b>optional </b> </li>
60 * <li>12: DG1 (Diagnosis) <b>optional repeating</b> </li>
61 * <li>13: DRG (Diagnosis Related Group) <b>optional repeating</b> </li>
62 * <li>14: AL1 (Patient Allergy Information) <b>optional repeating</b> </li>
63 * <li>15: REF_I12_PROCEDURE (a Group object) <b>optional repeating</b> </li>
64 * <li>16: REF_I12_OBSERVATION (a Group object) <b>optional repeating</b> </li>
65 * <li>17: REF_I12_PATIENT_VISIT (a Group object) <b>optional </b> </li>
66 * <li>18: NTE (Notes and Comments) <b>optional repeating</b> </li>
67 * </ul>
68 */
69 //@SuppressWarnings("unused")
70 public class REF_I12 extends AbstractMessage {
71
72 /**
73 * Creates a new REF_I12 message with DefaultModelClassFactory.
74 */
75 public REF_I12() {
76 this(new DefaultModelClassFactory());
77 }
78
79 /**
80 * Creates a new REF_I12 message with custom ModelClassFactory.
81 */
82 public REF_I12(ModelClassFactory factory) {
83 super(factory);
84 init(factory);
85 }
86
87 private void init(ModelClassFactory factory) {
88 try {
89 this.add(MSH.class, true, false);
90 this.add(SFT.class, false, true);
91 this.add(UAC.class, false, false);
92 this.add(RF1.class, false, false);
93 this.add(REF_I12_AUTHORIZATION_CONTACT2.class, false, false);
94 this.add(REF_I12_PROVIDER_CONTACT.class, true, true);
95 this.add(PID.class, true, false);
96 this.add(NK1.class, false, true);
97 this.add(GT1.class, false, true);
98 this.add(REF_I12_INSURANCE.class, false, true);
99 this.add(ACC.class, false, false);
100 this.add(DG1.class, false, true);
101 this.add(DRG.class, false, true);
102 this.add(AL1.class, false, true);
103 this.add(REF_I12_PROCEDURE.class, false, true);
104 this.add(REF_I12_OBSERVATION.class, false, true);
105 this.add(REF_I12_PATIENT_VISIT.class, false, false);
106 this.add(NTE.class, false, true);
107 } catch(HL7Exception e) {
108 log.error("Unexpected error creating REF_I12 - this is probably a bug in the source code generator.", e);
109 }
110 }
111
112
113 /**
114 * Returns "2.8.1"
115 */
116 public String getVersion() {
117 return "2.8.1";
118 }
119
120
121
122
123 /**
124 * <p>
125 * Returns
126 * MSH (Message Header) - creates it if necessary
127 * </p>
128 *
129 *
130 */
131 public MSH getMSH() {
132 return getTyped("MSH", MSH.class);
133 }
134
135
136
137
138
139 /**
140 * <p>
141 * Returns
142 * the first repetition of
143 * SFT (Software Segment) - creates it if necessary
144 * </p>
145 *
146 *
147 */
148 public SFT getSFT() {
149 return getTyped("SFT", SFT.class);
150 }
151
152
153 /**
154 * <p>
155 * Returns a specific repetition of
156 * SFT (Software Segment) - creates it if necessary
157 * </p>
158 *
159 *
160 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
161 * @throws HL7Exception if the repetition requested is more than one
162 * greater than the number of existing repetitions.
163 */
164 public SFT getSFT(int rep) {
165 return getTyped("SFT", rep, SFT.class);
166 }
167
168 /**
169 * <p>
170 * Returns the number of existing repetitions of SFT
171 * </p>
172 *
173 */
174 public int getSFTReps() {
175 return getReps("SFT");
176 }
177
178 /**
179 * <p>
180 * Returns a non-modifiable List containing all current existing repetitions of SFT.
181 * <p>
182 * <p>
183 * Note that unlike {@link #getSFT()}, this method will not create any reps
184 * if none are already present, so an empty list may be returned.
185 * </p>
186 *
187 */
188 public java.util.List<SFT> getSFTAll() throws HL7Exception {
189 return getAllAsList("SFT", SFT.class);
190 }
191
192 /**
193 * <p>
194 * Inserts a specific repetition of SFT (Software Segment)
195 * </p>
196 *
197 *
198 * @see AbstractGroup#insertRepetition(Structure, int)
199 */
200 public void insertSFT(SFT structure, int rep) throws HL7Exception {
201 super.insertRepetition( "SFT", structure, rep);
202 }
203
204
205 /**
206 * <p>
207 * Inserts a specific repetition of SFT (Software Segment)
208 * </p>
209 *
210 *
211 * @see AbstractGroup#insertRepetition(Structure, int)
212 */
213 public SFT insertSFT(int rep) throws HL7Exception {
214 return (SFT)super.insertRepetition("SFT", rep);
215 }
216
217
218 /**
219 * <p>
220 * Removes a specific repetition of SFT (Software Segment)
221 * </p>
222 *
223 *
224 * @see AbstractGroup#removeRepetition(String, int)
225 */
226 public SFT removeSFT(int rep) throws HL7Exception {
227 return (SFT)super.removeRepetition("SFT", rep);
228 }
229
230
231
232
233 /**
234 * <p>
235 * Returns
236 * UAC (User Authentication Credential Segment) - creates it if necessary
237 * </p>
238 *
239 *
240 */
241 public UAC getUAC() {
242 return getTyped("UAC", UAC.class);
243 }
244
245
246
247
248
249 /**
250 * <p>
251 * Returns
252 * RF1 (Referral Information) - creates it if necessary
253 * </p>
254 *
255 *
256 */
257 public RF1 getRF1() {
258 return getTyped("RF1", RF1.class);
259 }
260
261
262
263
264
265 /**
266 * <p>
267 * Returns
268 * AUTHORIZATION_CONTACT2 (a Group object) - creates it if necessary
269 * </p>
270 *
271 *
272 */
273 public REF_I12_AUTHORIZATION_CONTACT2 getAUTHORIZATION_CONTACT2() {
274 return getTyped("AUTHORIZATION_CONTACT2", REF_I12_AUTHORIZATION_CONTACT2.class);
275 }
276
277
278
279
280
281 /**
282 * <p>
283 * Returns
284 * the first repetition of
285 * PROVIDER_CONTACT (a Group object) - creates it if necessary
286 * </p>
287 *
288 *
289 */
290 public REF_I12_PROVIDER_CONTACT getPROVIDER_CONTACT() {
291 return getTyped("PROVIDER_CONTACT", REF_I12_PROVIDER_CONTACT.class);
292 }
293
294
295 /**
296 * <p>
297 * Returns a specific repetition of
298 * PROVIDER_CONTACT (a Group object) - creates it if necessary
299 * </p>
300 *
301 *
302 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
303 * @throws HL7Exception if the repetition requested is more than one
304 * greater than the number of existing repetitions.
305 */
306 public REF_I12_PROVIDER_CONTACT getPROVIDER_CONTACT(int rep) {
307 return getTyped("PROVIDER_CONTACT", rep, REF_I12_PROVIDER_CONTACT.class);
308 }
309
310 /**
311 * <p>
312 * Returns the number of existing repetitions of PROVIDER_CONTACT
313 * </p>
314 *
315 */
316 public int getPROVIDER_CONTACTReps() {
317 return getReps("PROVIDER_CONTACT");
318 }
319
320 /**
321 * <p>
322 * Returns a non-modifiable List containing all current existing repetitions of PROVIDER_CONTACT.
323 * <p>
324 * <p>
325 * Note that unlike {@link #getPROVIDER_CONTACT()}, this method will not create any reps
326 * if none are already present, so an empty list may be returned.
327 * </p>
328 *
329 */
330 public java.util.List<REF_I12_PROVIDER_CONTACT> getPROVIDER_CONTACTAll() throws HL7Exception {
331 return getAllAsList("PROVIDER_CONTACT", REF_I12_PROVIDER_CONTACT.class);
332 }
333
334 /**
335 * <p>
336 * Inserts a specific repetition of PROVIDER_CONTACT (a Group object)
337 * </p>
338 *
339 *
340 * @see AbstractGroup#insertRepetition(Structure, int)
341 */
342 public void insertPROVIDER_CONTACT(REF_I12_PROVIDER_CONTACT structure, int rep) throws HL7Exception {
343 super.insertRepetition( "PROVIDER_CONTACT", structure, rep);
344 }
345
346
347 /**
348 * <p>
349 * Inserts a specific repetition of PROVIDER_CONTACT (a Group object)
350 * </p>
351 *
352 *
353 * @see AbstractGroup#insertRepetition(Structure, int)
354 */
355 public REF_I12_PROVIDER_CONTACT insertPROVIDER_CONTACT(int rep) throws HL7Exception {
356 return (REF_I12_PROVIDER_CONTACT)super.insertRepetition("PROVIDER_CONTACT", rep);
357 }
358
359
360 /**
361 * <p>
362 * Removes a specific repetition of PROVIDER_CONTACT (a Group object)
363 * </p>
364 *
365 *
366 * @see AbstractGroup#removeRepetition(String, int)
367 */
368 public REF_I12_PROVIDER_CONTACT removePROVIDER_CONTACT(int rep) throws HL7Exception {
369 return (REF_I12_PROVIDER_CONTACT)super.removeRepetition("PROVIDER_CONTACT", rep);
370 }
371
372
373
374
375 /**
376 * <p>
377 * Returns
378 * PID (Patient Identification) - creates it if necessary
379 * </p>
380 *
381 *
382 */
383 public PID getPID() {
384 return getTyped("PID", PID.class);
385 }
386
387
388
389
390
391 /**
392 * <p>
393 * Returns
394 * the first repetition of
395 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
396 * </p>
397 *
398 *
399 */
400 public NK1 getNK1() {
401 return getTyped("NK1", NK1.class);
402 }
403
404
405 /**
406 * <p>
407 * Returns a specific repetition of
408 * NK1 (Next of Kin / Associated Parties) - creates it if necessary
409 * </p>
410 *
411 *
412 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
413 * @throws HL7Exception if the repetition requested is more than one
414 * greater than the number of existing repetitions.
415 */
416 public NK1 getNK1(int rep) {
417 return getTyped("NK1", rep, NK1.class);
418 }
419
420 /**
421 * <p>
422 * Returns the number of existing repetitions of NK1
423 * </p>
424 *
425 */
426 public int getNK1Reps() {
427 return getReps("NK1");
428 }
429
430 /**
431 * <p>
432 * Returns a non-modifiable List containing all current existing repetitions of NK1.
433 * <p>
434 * <p>
435 * Note that unlike {@link #getNK1()}, this method will not create any reps
436 * if none are already present, so an empty list may be returned.
437 * </p>
438 *
439 */
440 public java.util.List<NK1> getNK1All() throws HL7Exception {
441 return getAllAsList("NK1", NK1.class);
442 }
443
444 /**
445 * <p>
446 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
447 * </p>
448 *
449 *
450 * @see AbstractGroup#insertRepetition(Structure, int)
451 */
452 public void insertNK1(NK1 structure, int rep) throws HL7Exception {
453 super.insertRepetition( "NK1", structure, rep);
454 }
455
456
457 /**
458 * <p>
459 * Inserts a specific repetition of NK1 (Next of Kin / Associated Parties)
460 * </p>
461 *
462 *
463 * @see AbstractGroup#insertRepetition(Structure, int)
464 */
465 public NK1 insertNK1(int rep) throws HL7Exception {
466 return (NK1)super.insertRepetition("NK1", rep);
467 }
468
469
470 /**
471 * <p>
472 * Removes a specific repetition of NK1 (Next of Kin / Associated Parties)
473 * </p>
474 *
475 *
476 * @see AbstractGroup#removeRepetition(String, int)
477 */
478 public NK1 removeNK1(int rep) throws HL7Exception {
479 return (NK1)super.removeRepetition("NK1", rep);
480 }
481
482
483
484
485 /**
486 * <p>
487 * Returns
488 * the first repetition of
489 * GT1 (Guarantor) - creates it if necessary
490 * </p>
491 *
492 *
493 */
494 public GT1 getGT1() {
495 return getTyped("GT1", GT1.class);
496 }
497
498
499 /**
500 * <p>
501 * Returns a specific repetition of
502 * GT1 (Guarantor) - creates it if necessary
503 * </p>
504 *
505 *
506 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
507 * @throws HL7Exception if the repetition requested is more than one
508 * greater than the number of existing repetitions.
509 */
510 public GT1 getGT1(int rep) {
511 return getTyped("GT1", rep, GT1.class);
512 }
513
514 /**
515 * <p>
516 * Returns the number of existing repetitions of GT1
517 * </p>
518 *
519 */
520 public int getGT1Reps() {
521 return getReps("GT1");
522 }
523
524 /**
525 * <p>
526 * Returns a non-modifiable List containing all current existing repetitions of GT1.
527 * <p>
528 * <p>
529 * Note that unlike {@link #getGT1()}, this method will not create any reps
530 * if none are already present, so an empty list may be returned.
531 * </p>
532 *
533 */
534 public java.util.List<GT1> getGT1All() throws HL7Exception {
535 return getAllAsList("GT1", GT1.class);
536 }
537
538 /**
539 * <p>
540 * Inserts a specific repetition of GT1 (Guarantor)
541 * </p>
542 *
543 *
544 * @see AbstractGroup#insertRepetition(Structure, int)
545 */
546 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
547 super.insertRepetition( "GT1", structure, rep);
548 }
549
550
551 /**
552 * <p>
553 * Inserts a specific repetition of GT1 (Guarantor)
554 * </p>
555 *
556 *
557 * @see AbstractGroup#insertRepetition(Structure, int)
558 */
559 public GT1 insertGT1(int rep) throws HL7Exception {
560 return (GT1)super.insertRepetition("GT1", rep);
561 }
562
563
564 /**
565 * <p>
566 * Removes a specific repetition of GT1 (Guarantor)
567 * </p>
568 *
569 *
570 * @see AbstractGroup#removeRepetition(String, int)
571 */
572 public GT1 removeGT1(int rep) throws HL7Exception {
573 return (GT1)super.removeRepetition("GT1", rep);
574 }
575
576
577
578
579 /**
580 * <p>
581 * Returns
582 * the first repetition of
583 * INSURANCE (a Group object) - creates it if necessary
584 * </p>
585 *
586 *
587 */
588 public REF_I12_INSURANCE getINSURANCE() {
589 return getTyped("INSURANCE", REF_I12_INSURANCE.class);
590 }
591
592
593 /**
594 * <p>
595 * Returns a specific repetition of
596 * INSURANCE (a Group object) - creates it if necessary
597 * </p>
598 *
599 *
600 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
601 * @throws HL7Exception if the repetition requested is more than one
602 * greater than the number of existing repetitions.
603 */
604 public REF_I12_INSURANCE getINSURANCE(int rep) {
605 return getTyped("INSURANCE", rep, REF_I12_INSURANCE.class);
606 }
607
608 /**
609 * <p>
610 * Returns the number of existing repetitions of INSURANCE
611 * </p>
612 *
613 */
614 public int getINSURANCEReps() {
615 return getReps("INSURANCE");
616 }
617
618 /**
619 * <p>
620 * Returns a non-modifiable List containing all current existing repetitions of INSURANCE.
621 * <p>
622 * <p>
623 * Note that unlike {@link #getINSURANCE()}, this method will not create any reps
624 * if none are already present, so an empty list may be returned.
625 * </p>
626 *
627 */
628 public java.util.List<REF_I12_INSURANCE> getINSURANCEAll() throws HL7Exception {
629 return getAllAsList("INSURANCE", REF_I12_INSURANCE.class);
630 }
631
632 /**
633 * <p>
634 * Inserts a specific repetition of INSURANCE (a Group object)
635 * </p>
636 *
637 *
638 * @see AbstractGroup#insertRepetition(Structure, int)
639 */
640 public void insertINSURANCE(REF_I12_INSURANCE structure, int rep) throws HL7Exception {
641 super.insertRepetition( "INSURANCE", structure, rep);
642 }
643
644
645 /**
646 * <p>
647 * Inserts a specific repetition of INSURANCE (a Group object)
648 * </p>
649 *
650 *
651 * @see AbstractGroup#insertRepetition(Structure, int)
652 */
653 public REF_I12_INSURANCE insertINSURANCE(int rep) throws HL7Exception {
654 return (REF_I12_INSURANCE)super.insertRepetition("INSURANCE", rep);
655 }
656
657
658 /**
659 * <p>
660 * Removes a specific repetition of INSURANCE (a Group object)
661 * </p>
662 *
663 *
664 * @see AbstractGroup#removeRepetition(String, int)
665 */
666 public REF_I12_INSURANCE removeINSURANCE(int rep) throws HL7Exception {
667 return (REF_I12_INSURANCE)super.removeRepetition("INSURANCE", rep);
668 }
669
670
671
672
673 /**
674 * <p>
675 * Returns
676 * ACC (Accident) - creates it if necessary
677 * </p>
678 *
679 *
680 */
681 public ACC getACC() {
682 return getTyped("ACC", ACC.class);
683 }
684
685
686
687
688
689 /**
690 * <p>
691 * Returns
692 * the first repetition of
693 * DG1 (Diagnosis) - creates it if necessary
694 * </p>
695 *
696 *
697 */
698 public DG1 getDG1() {
699 return getTyped("DG1", DG1.class);
700 }
701
702
703 /**
704 * <p>
705 * Returns a specific repetition of
706 * DG1 (Diagnosis) - creates it if necessary
707 * </p>
708 *
709 *
710 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
711 * @throws HL7Exception if the repetition requested is more than one
712 * greater than the number of existing repetitions.
713 */
714 public DG1 getDG1(int rep) {
715 return getTyped("DG1", rep, DG1.class);
716 }
717
718 /**
719 * <p>
720 * Returns the number of existing repetitions of DG1
721 * </p>
722 *
723 */
724 public int getDG1Reps() {
725 return getReps("DG1");
726 }
727
728 /**
729 * <p>
730 * Returns a non-modifiable List containing all current existing repetitions of DG1.
731 * <p>
732 * <p>
733 * Note that unlike {@link #getDG1()}, this method will not create any reps
734 * if none are already present, so an empty list may be returned.
735 * </p>
736 *
737 */
738 public java.util.List<DG1> getDG1All() throws HL7Exception {
739 return getAllAsList("DG1", DG1.class);
740 }
741
742 /**
743 * <p>
744 * Inserts a specific repetition of DG1 (Diagnosis)
745 * </p>
746 *
747 *
748 * @see AbstractGroup#insertRepetition(Structure, int)
749 */
750 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
751 super.insertRepetition( "DG1", structure, rep);
752 }
753
754
755 /**
756 * <p>
757 * Inserts a specific repetition of DG1 (Diagnosis)
758 * </p>
759 *
760 *
761 * @see AbstractGroup#insertRepetition(Structure, int)
762 */
763 public DG1 insertDG1(int rep) throws HL7Exception {
764 return (DG1)super.insertRepetition("DG1", rep);
765 }
766
767
768 /**
769 * <p>
770 * Removes a specific repetition of DG1 (Diagnosis)
771 * </p>
772 *
773 *
774 * @see AbstractGroup#removeRepetition(String, int)
775 */
776 public DG1 removeDG1(int rep) throws HL7Exception {
777 return (DG1)super.removeRepetition("DG1", rep);
778 }
779
780
781
782
783 /**
784 * <p>
785 * Returns
786 * the first repetition of
787 * DRG (Diagnosis Related Group) - creates it if necessary
788 * </p>
789 *
790 *
791 */
792 public DRG getDRG() {
793 return getTyped("DRG", DRG.class);
794 }
795
796
797 /**
798 * <p>
799 * Returns a specific repetition of
800 * DRG (Diagnosis Related Group) - creates it if necessary
801 * </p>
802 *
803 *
804 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
805 * @throws HL7Exception if the repetition requested is more than one
806 * greater than the number of existing repetitions.
807 */
808 public DRG getDRG(int rep) {
809 return getTyped("DRG", rep, DRG.class);
810 }
811
812 /**
813 * <p>
814 * Returns the number of existing repetitions of DRG
815 * </p>
816 *
817 */
818 public int getDRGReps() {
819 return getReps("DRG");
820 }
821
822 /**
823 * <p>
824 * Returns a non-modifiable List containing all current existing repetitions of DRG.
825 * <p>
826 * <p>
827 * Note that unlike {@link #getDRG()}, this method will not create any reps
828 * if none are already present, so an empty list may be returned.
829 * </p>
830 *
831 */
832 public java.util.List<DRG> getDRGAll() throws HL7Exception {
833 return getAllAsList("DRG", DRG.class);
834 }
835
836 /**
837 * <p>
838 * Inserts a specific repetition of DRG (Diagnosis Related Group)
839 * </p>
840 *
841 *
842 * @see AbstractGroup#insertRepetition(Structure, int)
843 */
844 public void insertDRG(DRG structure, int rep) throws HL7Exception {
845 super.insertRepetition( "DRG", structure, rep);
846 }
847
848
849 /**
850 * <p>
851 * Inserts a specific repetition of DRG (Diagnosis Related Group)
852 * </p>
853 *
854 *
855 * @see AbstractGroup#insertRepetition(Structure, int)
856 */
857 public DRG insertDRG(int rep) throws HL7Exception {
858 return (DRG)super.insertRepetition("DRG", rep);
859 }
860
861
862 /**
863 * <p>
864 * Removes a specific repetition of DRG (Diagnosis Related Group)
865 * </p>
866 *
867 *
868 * @see AbstractGroup#removeRepetition(String, int)
869 */
870 public DRG removeDRG(int rep) throws HL7Exception {
871 return (DRG)super.removeRepetition("DRG", rep);
872 }
873
874
875
876
877 /**
878 * <p>
879 * Returns
880 * the first repetition of
881 * AL1 (Patient Allergy Information) - creates it if necessary
882 * </p>
883 *
884 *
885 */
886 public AL1 getAL1() {
887 return getTyped("AL1", AL1.class);
888 }
889
890
891 /**
892 * <p>
893 * Returns a specific repetition of
894 * AL1 (Patient Allergy Information) - creates it if necessary
895 * </p>
896 *
897 *
898 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
899 * @throws HL7Exception if the repetition requested is more than one
900 * greater than the number of existing repetitions.
901 */
902 public AL1 getAL1(int rep) {
903 return getTyped("AL1", rep, AL1.class);
904 }
905
906 /**
907 * <p>
908 * Returns the number of existing repetitions of AL1
909 * </p>
910 *
911 */
912 public int getAL1Reps() {
913 return getReps("AL1");
914 }
915
916 /**
917 * <p>
918 * Returns a non-modifiable List containing all current existing repetitions of AL1.
919 * <p>
920 * <p>
921 * Note that unlike {@link #getAL1()}, this method will not create any reps
922 * if none are already present, so an empty list may be returned.
923 * </p>
924 *
925 */
926 public java.util.List<AL1> getAL1All() throws HL7Exception {
927 return getAllAsList("AL1", AL1.class);
928 }
929
930 /**
931 * <p>
932 * Inserts a specific repetition of AL1 (Patient Allergy Information)
933 * </p>
934 *
935 *
936 * @see AbstractGroup#insertRepetition(Structure, int)
937 */
938 public void insertAL1(AL1 structure, int rep) throws HL7Exception {
939 super.insertRepetition( "AL1", structure, rep);
940 }
941
942
943 /**
944 * <p>
945 * Inserts a specific repetition of AL1 (Patient Allergy Information)
946 * </p>
947 *
948 *
949 * @see AbstractGroup#insertRepetition(Structure, int)
950 */
951 public AL1 insertAL1(int rep) throws HL7Exception {
952 return (AL1)super.insertRepetition("AL1", rep);
953 }
954
955
956 /**
957 * <p>
958 * Removes a specific repetition of AL1 (Patient Allergy Information)
959 * </p>
960 *
961 *
962 * @see AbstractGroup#removeRepetition(String, int)
963 */
964 public AL1 removeAL1(int rep) throws HL7Exception {
965 return (AL1)super.removeRepetition("AL1", rep);
966 }
967
968
969
970
971 /**
972 * <p>
973 * Returns
974 * the first repetition of
975 * PROCEDURE (a Group object) - creates it if necessary
976 * </p>
977 *
978 *
979 */
980 public REF_I12_PROCEDURE getPROCEDURE() {
981 return getTyped("PROCEDURE", REF_I12_PROCEDURE.class);
982 }
983
984
985 /**
986 * <p>
987 * Returns a specific repetition of
988 * PROCEDURE (a Group object) - creates it if necessary
989 * </p>
990 *
991 *
992 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
993 * @throws HL7Exception if the repetition requested is more than one
994 * greater than the number of existing repetitions.
995 */
996 public REF_I12_PROCEDURE getPROCEDURE(int rep) {
997 return getTyped("PROCEDURE", rep, REF_I12_PROCEDURE.class);
998 }
999
1000 /**
1001 * <p>
1002 * Returns the number of existing repetitions of PROCEDURE
1003 * </p>
1004 *
1005 */
1006 public int getPROCEDUREReps() {
1007 return getReps("PROCEDURE");
1008 }
1009
1010 /**
1011 * <p>
1012 * Returns a non-modifiable List containing all current existing repetitions of PROCEDURE.
1013 * <p>
1014 * <p>
1015 * Note that unlike {@link #getPROCEDURE()}, this method will not create any reps
1016 * if none are already present, so an empty list may be returned.
1017 * </p>
1018 *
1019 */
1020 public java.util.List<REF_I12_PROCEDURE> getPROCEDUREAll() throws HL7Exception {
1021 return getAllAsList("PROCEDURE", REF_I12_PROCEDURE.class);
1022 }
1023
1024 /**
1025 * <p>
1026 * Inserts a specific repetition of PROCEDURE (a Group object)
1027 * </p>
1028 *
1029 *
1030 * @see AbstractGroup#insertRepetition(Structure, int)
1031 */
1032 public void insertPROCEDURE(REF_I12_PROCEDURE structure, int rep) throws HL7Exception {
1033 super.insertRepetition( "PROCEDURE", structure, rep);
1034 }
1035
1036
1037 /**
1038 * <p>
1039 * Inserts a specific repetition of PROCEDURE (a Group object)
1040 * </p>
1041 *
1042 *
1043 * @see AbstractGroup#insertRepetition(Structure, int)
1044 */
1045 public REF_I12_PROCEDURE insertPROCEDURE(int rep) throws HL7Exception {
1046 return (REF_I12_PROCEDURE)super.insertRepetition("PROCEDURE", rep);
1047 }
1048
1049
1050 /**
1051 * <p>
1052 * Removes a specific repetition of PROCEDURE (a Group object)
1053 * </p>
1054 *
1055 *
1056 * @see AbstractGroup#removeRepetition(String, int)
1057 */
1058 public REF_I12_PROCEDURE removePROCEDURE(int rep) throws HL7Exception {
1059 return (REF_I12_PROCEDURE)super.removeRepetition("PROCEDURE", rep);
1060 }
1061
1062
1063
1064
1065 /**
1066 * <p>
1067 * Returns
1068 * the first repetition of
1069 * OBSERVATION (a Group object) - creates it if necessary
1070 * </p>
1071 *
1072 *
1073 */
1074 public REF_I12_OBSERVATION getOBSERVATION() {
1075 return getTyped("OBSERVATION", REF_I12_OBSERVATION.class);
1076 }
1077
1078
1079 /**
1080 * <p>
1081 * Returns a specific repetition of
1082 * OBSERVATION (a Group object) - creates it if necessary
1083 * </p>
1084 *
1085 *
1086 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1087 * @throws HL7Exception if the repetition requested is more than one
1088 * greater than the number of existing repetitions.
1089 */
1090 public REF_I12_OBSERVATION getOBSERVATION(int rep) {
1091 return getTyped("OBSERVATION", rep, REF_I12_OBSERVATION.class);
1092 }
1093
1094 /**
1095 * <p>
1096 * Returns the number of existing repetitions of OBSERVATION
1097 * </p>
1098 *
1099 */
1100 public int getOBSERVATIONReps() {
1101 return getReps("OBSERVATION");
1102 }
1103
1104 /**
1105 * <p>
1106 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION.
1107 * <p>
1108 * <p>
1109 * Note that unlike {@link #getOBSERVATION()}, this method will not create any reps
1110 * if none are already present, so an empty list may be returned.
1111 * </p>
1112 *
1113 */
1114 public java.util.List<REF_I12_OBSERVATION> getOBSERVATIONAll() throws HL7Exception {
1115 return getAllAsList("OBSERVATION", REF_I12_OBSERVATION.class);
1116 }
1117
1118 /**
1119 * <p>
1120 * Inserts a specific repetition of OBSERVATION (a Group object)
1121 * </p>
1122 *
1123 *
1124 * @see AbstractGroup#insertRepetition(Structure, int)
1125 */
1126 public void insertOBSERVATION(REF_I12_OBSERVATION structure, int rep) throws HL7Exception {
1127 super.insertRepetition( "OBSERVATION", structure, rep);
1128 }
1129
1130
1131 /**
1132 * <p>
1133 * Inserts a specific repetition of OBSERVATION (a Group object)
1134 * </p>
1135 *
1136 *
1137 * @see AbstractGroup#insertRepetition(Structure, int)
1138 */
1139 public REF_I12_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception {
1140 return (REF_I12_OBSERVATION)super.insertRepetition("OBSERVATION", rep);
1141 }
1142
1143
1144 /**
1145 * <p>
1146 * Removes a specific repetition of OBSERVATION (a Group object)
1147 * </p>
1148 *
1149 *
1150 * @see AbstractGroup#removeRepetition(String, int)
1151 */
1152 public REF_I12_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception {
1153 return (REF_I12_OBSERVATION)super.removeRepetition("OBSERVATION", rep);
1154 }
1155
1156
1157
1158
1159 /**
1160 * <p>
1161 * Returns
1162 * PATIENT_VISIT (a Group object) - creates it if necessary
1163 * </p>
1164 *
1165 *
1166 */
1167 public REF_I12_PATIENT_VISIT getPATIENT_VISIT() {
1168 return getTyped("PATIENT_VISIT", REF_I12_PATIENT_VISIT.class);
1169 }
1170
1171
1172
1173
1174
1175 /**
1176 * <p>
1177 * Returns
1178 * the first repetition of
1179 * NTE (Notes and Comments) - creates it if necessary
1180 * </p>
1181 *
1182 *
1183 */
1184 public NTE getNTE() {
1185 return getTyped("NTE", NTE.class);
1186 }
1187
1188
1189 /**
1190 * <p>
1191 * Returns a specific repetition of
1192 * NTE (Notes and Comments) - creates it if necessary
1193 * </p>
1194 *
1195 *
1196 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
1197 * @throws HL7Exception if the repetition requested is more than one
1198 * greater than the number of existing repetitions.
1199 */
1200 public NTE getNTE(int rep) {
1201 return getTyped("NTE", rep, NTE.class);
1202 }
1203
1204 /**
1205 * <p>
1206 * Returns the number of existing repetitions of NTE
1207 * </p>
1208 *
1209 */
1210 public int getNTEReps() {
1211 return getReps("NTE");
1212 }
1213
1214 /**
1215 * <p>
1216 * Returns a non-modifiable List containing all current existing repetitions of NTE.
1217 * <p>
1218 * <p>
1219 * Note that unlike {@link #getNTE()}, this method will not create any reps
1220 * if none are already present, so an empty list may be returned.
1221 * </p>
1222 *
1223 */
1224 public java.util.List<NTE> getNTEAll() throws HL7Exception {
1225 return getAllAsList("NTE", NTE.class);
1226 }
1227
1228 /**
1229 * <p>
1230 * Inserts a specific repetition of NTE (Notes and Comments)
1231 * </p>
1232 *
1233 *
1234 * @see AbstractGroup#insertRepetition(Structure, int)
1235 */
1236 public void insertNTE(NTE structure, int rep) throws HL7Exception {
1237 super.insertRepetition( "NTE", structure, rep);
1238 }
1239
1240
1241 /**
1242 * <p>
1243 * Inserts a specific repetition of NTE (Notes and Comments)
1244 * </p>
1245 *
1246 *
1247 * @see AbstractGroup#insertRepetition(Structure, int)
1248 */
1249 public NTE insertNTE(int rep) throws HL7Exception {
1250 return (NTE)super.insertRepetition("NTE", rep);
1251 }
1252
1253
1254 /**
1255 * <p>
1256 * Removes a specific repetition of NTE (Notes and Comments)
1257 * </p>
1258 *
1259 *
1260 * @see AbstractGroup#removeRepetition(String, int)
1261 */
1262 public NTE removeNTE(int rep) throws HL7Exception {
1263 return (NTE)super.removeRepetition("NTE", rep);
1264 }
1265
1266
1267
1268 }
1269