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