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