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