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.v26.group;
35
36 import ca.uhn.hl7v2.model.v26.segment.*;
37
38 import ca.uhn.hl7v2.HL7Exception;
39 import ca.uhn.hl7v2.parser.ModelClassFactory;
40 import ca.uhn.hl7v2.model.*;
41
42 /**
43 * <p>Represents a OMG_O19_ORDER group structure (a Group object).
44 * A Group is an ordered collection of message segments that can repeat together or be optionally in/excluded together.
45 * This Group contains the following elements:
46 * </p>
47 * <ul>
48 * <li>1: ORC (Common Order) <b> </b></li>
49 * <li>2: OMG_O19_TIMING (a Group object) <b>optional repeating </b></li>
50 * <li>3: OBR (Observation Request) <b> </b></li>
51 * <li>4: NTE (Notes and Comments) <b>optional repeating </b></li>
52 * <li>5: ROL (Role) <b>optional repeating </b></li>
53 * <li>6: CTD (Contact Data) <b>optional </b></li>
54 * <li>7: DG1 (Diagnosis) <b>optional repeating </b></li>
55 * <li>8: OMG_O19_OBSERVATION (a Group object) <b>optional repeating </b></li>
56 * <li>9: OMG_O19_SPECIMEN (a Group object) <b>optional repeating </b></li>
57 * <li>10: OMG_O19_PRIOR_RESULT (a Group object) <b>optional repeating </b></li>
58 * <li>11: FT1 (Financial Transaction) <b>optional repeating </b></li>
59 * <li>12: CTI (Clinical Trial Identification) <b>optional repeating </b></li>
60 * <li>13: BLG (Billing) <b>optional </b></li>
61 * </ul>
62 */
63 //@SuppressWarnings("unused")
64 public class OMG_O19_ORDER extends AbstractGroup {
65
66 /**
67 * Creates a new OMG_O19_ORDER group
68 */
69 public OMG_O19_ORDER(Group parent, ModelClassFactory factory) {
70 super(parent, factory);
71 init(factory);
72 }
73
74 private void init(ModelClassFactory factory) {
75 try {
76 this.add(ORC.class, true, false, false);
77 this.add(OMG_O19_TIMING.class, false, true, false);
78 this.add(OBR.class, true, false, false);
79 this.add(NTE.class, false, true, false);
80 this.add(ROL.class, false, true, false);
81 this.add(CTD.class, false, false, false);
82 this.add(DG1.class, false, true, false);
83 this.add(OMG_O19_OBSERVATION.class, false, true, false);
84 this.add(OMG_O19_SPECIMEN.class, false, true, false);
85 this.add(OMG_O19_PRIOR_RESULT.class, false, true, false);
86 this.add(FT1.class, false, true, false);
87 this.add(CTI.class, false, true, false);
88 this.add(BLG.class, false, false, false);
89 } catch(HL7Exception e) {
90 log.error("Unexpected error creating OMG_O19_ORDER - this is probably a bug in the source code generator.", e);
91 }
92 }
93
94 /**
95 * Returns "2.6"
96 */
97 public String getVersion() {
98 return "2.6";
99 }
100
101
102
103 /**
104 * Returns
105 * ORC (Common Order) - creates it if necessary
106 */
107 public ORC getORC() {
108 ORC retVal = getTyped("ORC", ORC.class);
109 return retVal;
110 }
111
112
113
114
115 /**
116 * Returns
117 * the first repetition of
118 * TIMING (a Group object) - creates it if necessary
119 */
120 public OMG_O19_TIMING getTIMING() {
121 OMG_O19_TIMING retVal = getTyped("TIMING", OMG_O19_TIMING.class);
122 return retVal;
123 }
124
125
126 /**
127 * Returns a specific repetition of
128 * TIMING (a Group object) - creates it if necessary
129 *
130 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
131 * @throws HL7Exception if the repetition requested is more than one
132 * greater than the number of existing repetitions.
133 */
134 public OMG_O19_TIMING getTIMING(int rep) {
135 OMG_O19_TIMING retVal = getTyped("TIMING", rep, OMG_O19_TIMING.class);
136 return retVal;
137 }
138
139 /**
140 * Returns the number of existing repetitions of TIMING
141 */
142 public int getTIMINGReps() {
143 return getReps("TIMING");
144 }
145
146 /**
147 * <p>
148 * Returns a non-modifiable List containing all current existing repetitions of TIMING.
149 * <p>
150 * <p>
151 * Note that unlike {@link #getTIMING()}, this method will not create any reps
152 * if none are already present, so an empty list may be returned.
153 * </p>
154 */
155 public java.util.List<OMG_O19_TIMING> getTIMINGAll() throws HL7Exception {
156 return getAllAsList("TIMING", OMG_O19_TIMING.class);
157 }
158
159 /**
160 * Inserts a specific repetition of TIMING (a Group object)
161 * @see AbstractGroup#insertRepetition(Structure, int)
162 */
163 public void insertTIMING(OMG_O19_TIMING structure, int rep) throws HL7Exception {
164 super.insertRepetition("TIMING", structure, rep);
165 }
166
167
168 /**
169 * Inserts a specific repetition of TIMING (a Group object)
170 * @see AbstractGroup#insertRepetition(Structure, int)
171 */
172 public OMG_O19_TIMING insertTIMING(int rep) throws HL7Exception {
173 return (OMG_O19_TIMING)super.insertRepetition("TIMING", rep);
174 }
175
176
177 /**
178 * Removes a specific repetition of TIMING (a Group object)
179 * @see AbstractGroup#removeRepetition(String, int)
180 */
181 public OMG_O19_TIMING removeTIMING(int rep) throws HL7Exception {
182 return (OMG_O19_TIMING)super.removeRepetition("TIMING", rep);
183 }
184
185
186
187 /**
188 * Returns
189 * OBR (Observation Request) - creates it if necessary
190 */
191 public OBR getOBR() {
192 OBR retVal = getTyped("OBR", OBR.class);
193 return retVal;
194 }
195
196
197
198
199 /**
200 * Returns
201 * the first repetition of
202 * NTE (Notes and Comments) - creates it if necessary
203 */
204 public NTE getNTE() {
205 NTE retVal = getTyped("NTE", NTE.class);
206 return retVal;
207 }
208
209
210 /**
211 * Returns a specific repetition of
212 * NTE (Notes and Comments) - creates it if necessary
213 *
214 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
215 * @throws HL7Exception if the repetition requested is more than one
216 * greater than the number of existing repetitions.
217 */
218 public NTE getNTE(int rep) {
219 NTE retVal = getTyped("NTE", rep, NTE.class);
220 return retVal;
221 }
222
223 /**
224 * Returns the number of existing repetitions of NTE
225 */
226 public int getNTEReps() {
227 return getReps("NTE");
228 }
229
230 /**
231 * <p>
232 * Returns a non-modifiable List containing all current existing repetitions of NTE.
233 * <p>
234 * <p>
235 * Note that unlike {@link #getNTE()}, this method will not create any reps
236 * if none are already present, so an empty list may be returned.
237 * </p>
238 */
239 public java.util.List<NTE> getNTEAll() throws HL7Exception {
240 return getAllAsList("NTE", NTE.class);
241 }
242
243 /**
244 * Inserts a specific repetition of NTE (Notes and Comments)
245 * @see AbstractGroup#insertRepetition(Structure, int)
246 */
247 public void insertNTE(NTE structure, int rep) throws HL7Exception {
248 super.insertRepetition("NTE", structure, rep);
249 }
250
251
252 /**
253 * Inserts a specific repetition of NTE (Notes and Comments)
254 * @see AbstractGroup#insertRepetition(Structure, int)
255 */
256 public NTE insertNTE(int rep) throws HL7Exception {
257 return (NTE)super.insertRepetition("NTE", rep);
258 }
259
260
261 /**
262 * Removes a specific repetition of NTE (Notes and Comments)
263 * @see AbstractGroup#removeRepetition(String, int)
264 */
265 public NTE removeNTE(int rep) throws HL7Exception {
266 return (NTE)super.removeRepetition("NTE", rep);
267 }
268
269
270
271 /**
272 * Returns
273 * the first repetition of
274 * ROL (Role) - creates it if necessary
275 */
276 public ROL getROL() {
277 ROL retVal = getTyped("ROL", ROL.class);
278 return retVal;
279 }
280
281
282 /**
283 * Returns a specific repetition of
284 * ROL (Role) - creates it if necessary
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 ROL getROL(int rep) {
291 ROL retVal = getTyped("ROL", rep, ROL.class);
292 return retVal;
293 }
294
295 /**
296 * Returns the number of existing repetitions of ROL
297 */
298 public int getROLReps() {
299 return getReps("ROL");
300 }
301
302 /**
303 * <p>
304 * Returns a non-modifiable List containing all current existing repetitions of ROL.
305 * <p>
306 * <p>
307 * Note that unlike {@link #getROL()}, this method will not create any reps
308 * if none are already present, so an empty list may be returned.
309 * </p>
310 */
311 public java.util.List<ROL> getROLAll() throws HL7Exception {
312 return getAllAsList("ROL", ROL.class);
313 }
314
315 /**
316 * Inserts a specific repetition of ROL (Role)
317 * @see AbstractGroup#insertRepetition(Structure, int)
318 */
319 public void insertROL(ROL structure, int rep) throws HL7Exception {
320 super.insertRepetition("ROL", structure, rep);
321 }
322
323
324 /**
325 * Inserts a specific repetition of ROL (Role)
326 * @see AbstractGroup#insertRepetition(Structure, int)
327 */
328 public ROL insertROL(int rep) throws HL7Exception {
329 return (ROL)super.insertRepetition("ROL", rep);
330 }
331
332
333 /**
334 * Removes a specific repetition of ROL (Role)
335 * @see AbstractGroup#removeRepetition(String, int)
336 */
337 public ROL removeROL(int rep) throws HL7Exception {
338 return (ROL)super.removeRepetition("ROL", rep);
339 }
340
341
342
343 /**
344 * Returns
345 * CTD (Contact Data) - creates it if necessary
346 */
347 public CTD getCTD() {
348 CTD retVal = getTyped("CTD", CTD.class);
349 return retVal;
350 }
351
352
353
354
355 /**
356 * Returns
357 * the first repetition of
358 * DG1 (Diagnosis) - creates it if necessary
359 */
360 public DG1 getDG1() {
361 DG1 retVal = getTyped("DG1", DG1.class);
362 return retVal;
363 }
364
365
366 /**
367 * Returns a specific repetition of
368 * DG1 (Diagnosis) - creates it if necessary
369 *
370 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
371 * @throws HL7Exception if the repetition requested is more than one
372 * greater than the number of existing repetitions.
373 */
374 public DG1 getDG1(int rep) {
375 DG1 retVal = getTyped("DG1", rep, DG1.class);
376 return retVal;
377 }
378
379 /**
380 * Returns the number of existing repetitions of DG1
381 */
382 public int getDG1Reps() {
383 return getReps("DG1");
384 }
385
386 /**
387 * <p>
388 * Returns a non-modifiable List containing all current existing repetitions of DG1.
389 * <p>
390 * <p>
391 * Note that unlike {@link #getDG1()}, this method will not create any reps
392 * if none are already present, so an empty list may be returned.
393 * </p>
394 */
395 public java.util.List<DG1> getDG1All() throws HL7Exception {
396 return getAllAsList("DG1", DG1.class);
397 }
398
399 /**
400 * Inserts a specific repetition of DG1 (Diagnosis)
401 * @see AbstractGroup#insertRepetition(Structure, int)
402 */
403 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
404 super.insertRepetition("DG1", structure, rep);
405 }
406
407
408 /**
409 * Inserts a specific repetition of DG1 (Diagnosis)
410 * @see AbstractGroup#insertRepetition(Structure, int)
411 */
412 public DG1 insertDG1(int rep) throws HL7Exception {
413 return (DG1)super.insertRepetition("DG1", rep);
414 }
415
416
417 /**
418 * Removes a specific repetition of DG1 (Diagnosis)
419 * @see AbstractGroup#removeRepetition(String, int)
420 */
421 public DG1 removeDG1(int rep) throws HL7Exception {
422 return (DG1)super.removeRepetition("DG1", rep);
423 }
424
425
426
427 /**
428 * Returns
429 * the first repetition of
430 * OBSERVATION (a Group object) - creates it if necessary
431 */
432 public OMG_O19_OBSERVATION getOBSERVATION() {
433 OMG_O19_OBSERVATION retVal = getTyped("OBSERVATION", OMG_O19_OBSERVATION.class);
434 return retVal;
435 }
436
437
438 /**
439 * Returns a specific repetition of
440 * OBSERVATION (a Group object) - creates it if necessary
441 *
442 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
443 * @throws HL7Exception if the repetition requested is more than one
444 * greater than the number of existing repetitions.
445 */
446 public OMG_O19_OBSERVATION getOBSERVATION(int rep) {
447 OMG_O19_OBSERVATION retVal = getTyped("OBSERVATION", rep, OMG_O19_OBSERVATION.class);
448 return retVal;
449 }
450
451 /**
452 * Returns the number of existing repetitions of OBSERVATION
453 */
454 public int getOBSERVATIONReps() {
455 return getReps("OBSERVATION");
456 }
457
458 /**
459 * <p>
460 * Returns a non-modifiable List containing all current existing repetitions of OBSERVATION.
461 * <p>
462 * <p>
463 * Note that unlike {@link #getOBSERVATION()}, this method will not create any reps
464 * if none are already present, so an empty list may be returned.
465 * </p>
466 */
467 public java.util.List<OMG_O19_OBSERVATION> getOBSERVATIONAll() throws HL7Exception {
468 return getAllAsList("OBSERVATION", OMG_O19_OBSERVATION.class);
469 }
470
471 /**
472 * Inserts a specific repetition of OBSERVATION (a Group object)
473 * @see AbstractGroup#insertRepetition(Structure, int)
474 */
475 public void insertOBSERVATION(OMG_O19_OBSERVATION structure, int rep) throws HL7Exception {
476 super.insertRepetition("OBSERVATION", structure, rep);
477 }
478
479
480 /**
481 * Inserts a specific repetition of OBSERVATION (a Group object)
482 * @see AbstractGroup#insertRepetition(Structure, int)
483 */
484 public OMG_O19_OBSERVATION insertOBSERVATION(int rep) throws HL7Exception {
485 return (OMG_O19_OBSERVATION)super.insertRepetition("OBSERVATION", rep);
486 }
487
488
489 /**
490 * Removes a specific repetition of OBSERVATION (a Group object)
491 * @see AbstractGroup#removeRepetition(String, int)
492 */
493 public OMG_O19_OBSERVATION removeOBSERVATION(int rep) throws HL7Exception {
494 return (OMG_O19_OBSERVATION)super.removeRepetition("OBSERVATION", rep);
495 }
496
497
498
499 /**
500 * Returns
501 * the first repetition of
502 * SPECIMEN (a Group object) - creates it if necessary
503 */
504 public OMG_O19_SPECIMEN getSPECIMEN() {
505 OMG_O19_SPECIMEN retVal = getTyped("SPECIMEN", OMG_O19_SPECIMEN.class);
506 return retVal;
507 }
508
509
510 /**
511 * Returns a specific repetition of
512 * SPECIMEN (a Group object) - creates it if necessary
513 *
514 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
515 * @throws HL7Exception if the repetition requested is more than one
516 * greater than the number of existing repetitions.
517 */
518 public OMG_O19_SPECIMEN getSPECIMEN(int rep) {
519 OMG_O19_SPECIMEN retVal = getTyped("SPECIMEN", rep, OMG_O19_SPECIMEN.class);
520 return retVal;
521 }
522
523 /**
524 * Returns the number of existing repetitions of SPECIMEN
525 */
526 public int getSPECIMENReps() {
527 return getReps("SPECIMEN");
528 }
529
530 /**
531 * <p>
532 * Returns a non-modifiable List containing all current existing repetitions of SPECIMEN.
533 * <p>
534 * <p>
535 * Note that unlike {@link #getSPECIMEN()}, this method will not create any reps
536 * if none are already present, so an empty list may be returned.
537 * </p>
538 */
539 public java.util.List<OMG_O19_SPECIMEN> getSPECIMENAll() throws HL7Exception {
540 return getAllAsList("SPECIMEN", OMG_O19_SPECIMEN.class);
541 }
542
543 /**
544 * Inserts a specific repetition of SPECIMEN (a Group object)
545 * @see AbstractGroup#insertRepetition(Structure, int)
546 */
547 public void insertSPECIMEN(OMG_O19_SPECIMEN structure, int rep) throws HL7Exception {
548 super.insertRepetition("SPECIMEN", structure, rep);
549 }
550
551
552 /**
553 * Inserts a specific repetition of SPECIMEN (a Group object)
554 * @see AbstractGroup#insertRepetition(Structure, int)
555 */
556 public OMG_O19_SPECIMEN insertSPECIMEN(int rep) throws HL7Exception {
557 return (OMG_O19_SPECIMEN)super.insertRepetition("SPECIMEN", rep);
558 }
559
560
561 /**
562 * Removes a specific repetition of SPECIMEN (a Group object)
563 * @see AbstractGroup#removeRepetition(String, int)
564 */
565 public OMG_O19_SPECIMEN removeSPECIMEN(int rep) throws HL7Exception {
566 return (OMG_O19_SPECIMEN)super.removeRepetition("SPECIMEN", rep);
567 }
568
569
570
571 /**
572 * Returns
573 * the first repetition of
574 * PRIOR_RESULT (a Group object) - creates it if necessary
575 */
576 public OMG_O19_PRIOR_RESULT getPRIOR_RESULT() {
577 OMG_O19_PRIOR_RESULT retVal = getTyped("PRIOR_RESULT", OMG_O19_PRIOR_RESULT.class);
578 return retVal;
579 }
580
581
582 /**
583 * Returns a specific repetition of
584 * PRIOR_RESULT (a Group object) - creates it if necessary
585 *
586 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
587 * @throws HL7Exception if the repetition requested is more than one
588 * greater than the number of existing repetitions.
589 */
590 public OMG_O19_PRIOR_RESULT getPRIOR_RESULT(int rep) {
591 OMG_O19_PRIOR_RESULT retVal = getTyped("PRIOR_RESULT", rep, OMG_O19_PRIOR_RESULT.class);
592 return retVal;
593 }
594
595 /**
596 * Returns the number of existing repetitions of PRIOR_RESULT
597 */
598 public int getPRIOR_RESULTReps() {
599 return getReps("PRIOR_RESULT");
600 }
601
602 /**
603 * <p>
604 * Returns a non-modifiable List containing all current existing repetitions of PRIOR_RESULT.
605 * <p>
606 * <p>
607 * Note that unlike {@link #getPRIOR_RESULT()}, this method will not create any reps
608 * if none are already present, so an empty list may be returned.
609 * </p>
610 */
611 public java.util.List<OMG_O19_PRIOR_RESULT> getPRIOR_RESULTAll() throws HL7Exception {
612 return getAllAsList("PRIOR_RESULT", OMG_O19_PRIOR_RESULT.class);
613 }
614
615 /**
616 * Inserts a specific repetition of PRIOR_RESULT (a Group object)
617 * @see AbstractGroup#insertRepetition(Structure, int)
618 */
619 public void insertPRIOR_RESULT(OMG_O19_PRIOR_RESULT structure, int rep) throws HL7Exception {
620 super.insertRepetition("PRIOR_RESULT", structure, rep);
621 }
622
623
624 /**
625 * Inserts a specific repetition of PRIOR_RESULT (a Group object)
626 * @see AbstractGroup#insertRepetition(Structure, int)
627 */
628 public OMG_O19_PRIOR_RESULT insertPRIOR_RESULT(int rep) throws HL7Exception {
629 return (OMG_O19_PRIOR_RESULT)super.insertRepetition("PRIOR_RESULT", rep);
630 }
631
632
633 /**
634 * Removes a specific repetition of PRIOR_RESULT (a Group object)
635 * @see AbstractGroup#removeRepetition(String, int)
636 */
637 public OMG_O19_PRIOR_RESULT removePRIOR_RESULT(int rep) throws HL7Exception {
638 return (OMG_O19_PRIOR_RESULT)super.removeRepetition("PRIOR_RESULT", rep);
639 }
640
641
642
643 /**
644 * Returns
645 * the first repetition of
646 * FT1 (Financial Transaction) - creates it if necessary
647 */
648 public FT1 getFT1() {
649 FT1 retVal = getTyped("FT1", FT1.class);
650 return retVal;
651 }
652
653
654 /**
655 * Returns a specific repetition of
656 * FT1 (Financial Transaction) - creates it if necessary
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 FT1 getFT1(int rep) {
663 FT1 retVal = getTyped("FT1", rep, FT1.class);
664 return retVal;
665 }
666
667 /**
668 * Returns the number of existing repetitions of FT1
669 */
670 public int getFT1Reps() {
671 return getReps("FT1");
672 }
673
674 /**
675 * <p>
676 * Returns a non-modifiable List containing all current existing repetitions of FT1.
677 * <p>
678 * <p>
679 * Note that unlike {@link #getFT1()}, this method will not create any reps
680 * if none are already present, so an empty list may be returned.
681 * </p>
682 */
683 public java.util.List<FT1> getFT1All() throws HL7Exception {
684 return getAllAsList("FT1", FT1.class);
685 }
686
687 /**
688 * Inserts a specific repetition of FT1 (Financial Transaction)
689 * @see AbstractGroup#insertRepetition(Structure, int)
690 */
691 public void insertFT1(FT1 structure, int rep) throws HL7Exception {
692 super.insertRepetition("FT1", structure, rep);
693 }
694
695
696 /**
697 * Inserts a specific repetition of FT1 (Financial Transaction)
698 * @see AbstractGroup#insertRepetition(Structure, int)
699 */
700 public FT1 insertFT1(int rep) throws HL7Exception {
701 return (FT1)super.insertRepetition("FT1", rep);
702 }
703
704
705 /**
706 * Removes a specific repetition of FT1 (Financial Transaction)
707 * @see AbstractGroup#removeRepetition(String, int)
708 */
709 public FT1 removeFT1(int rep) throws HL7Exception {
710 return (FT1)super.removeRepetition("FT1", rep);
711 }
712
713
714
715 /**
716 * Returns
717 * the first repetition of
718 * CTI (Clinical Trial Identification) - creates it if necessary
719 */
720 public CTI getCTI() {
721 CTI retVal = getTyped("CTI", CTI.class);
722 return retVal;
723 }
724
725
726 /**
727 * Returns a specific repetition of
728 * CTI (Clinical Trial Identification) - creates it if necessary
729 *
730 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
731 * @throws HL7Exception if the repetition requested is more than one
732 * greater than the number of existing repetitions.
733 */
734 public CTI getCTI(int rep) {
735 CTI retVal = getTyped("CTI", rep, CTI.class);
736 return retVal;
737 }
738
739 /**
740 * Returns the number of existing repetitions of CTI
741 */
742 public int getCTIReps() {
743 return getReps("CTI");
744 }
745
746 /**
747 * <p>
748 * Returns a non-modifiable List containing all current existing repetitions of CTI.
749 * <p>
750 * <p>
751 * Note that unlike {@link #getCTI()}, this method will not create any reps
752 * if none are already present, so an empty list may be returned.
753 * </p>
754 */
755 public java.util.List<CTI> getCTIAll() throws HL7Exception {
756 return getAllAsList("CTI", CTI.class);
757 }
758
759 /**
760 * Inserts a specific repetition of CTI (Clinical Trial Identification)
761 * @see AbstractGroup#insertRepetition(Structure, int)
762 */
763 public void insertCTI(CTI structure, int rep) throws HL7Exception {
764 super.insertRepetition("CTI", structure, rep);
765 }
766
767
768 /**
769 * Inserts a specific repetition of CTI (Clinical Trial Identification)
770 * @see AbstractGroup#insertRepetition(Structure, int)
771 */
772 public CTI insertCTI(int rep) throws HL7Exception {
773 return (CTI)super.insertRepetition("CTI", rep);
774 }
775
776
777 /**
778 * Removes a specific repetition of CTI (Clinical Trial Identification)
779 * @see AbstractGroup#removeRepetition(String, int)
780 */
781 public CTI removeCTI(int rep) throws HL7Exception {
782 return (CTI)super.removeRepetition("CTI", rep);
783 }
784
785
786
787 /**
788 * Returns
789 * BLG (Billing) - creates it if necessary
790 */
791 public BLG getBLG() {
792 BLG retVal = getTyped("BLG", BLG.class);
793 return retVal;
794 }
795
796
797
798
799 }
800