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