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