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