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