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.v25.group;
35
36 import ca.uhn.hl7v2.model.v25.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 DFT_P11_FINANCIAL 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: FT1 (Financial Transaction) <b> </b></li>
49 * <li>2: DFT_P11_FINANCIAL_PROCEDURE (a Group object) <b>optional repeating </b></li>
50 * <li>3: DFT_P11_FINANCIAL_COMMON_ORDER (a Group object) <b>optional repeating </b></li>
51 * <li>4: DG1 (Diagnosis) <b>optional repeating </b></li>
52 * <li>5: DRG (Diagnosis Related Group) <b>optional </b></li>
53 * <li>6: GT1 (Guarantor) <b>optional repeating </b></li>
54 * <li>7: DFT_P11_FINANCIAL_INSURANCE (a Group object) <b>optional repeating </b></li>
55 * </ul>
56 */
57 //@SuppressWarnings("unused")
58 public class DFT_P11_FINANCIAL extends AbstractGroup {
59
60 /**
61 * Creates a new DFT_P11_FINANCIAL group
62 */
63 public DFT_P11_FINANCIAL(Group parent, ModelClassFactory factory) {
64 super(parent, factory);
65 init(factory);
66 }
67
68 private void init(ModelClassFactory factory) {
69 try {
70 this.add(FT1.class, true, false, false);
71 this.add(DFT_P11_FINANCIAL_PROCEDURE.class, false, true, false);
72 this.add(DFT_P11_FINANCIAL_COMMON_ORDER.class, false, true, false);
73 this.add(DG1.class, false, true, false);
74 this.add(DRG.class, false, false, false);
75 this.add(GT1.class, false, true, false);
76 this.add(DFT_P11_FINANCIAL_INSURANCE.class, false, true, false);
77 } catch(HL7Exception e) {
78 log.error("Unexpected error creating DFT_P11_FINANCIAL - this is probably a bug in the source code generator.", e);
79 }
80 }
81
82 /**
83 * Returns "2.5"
84 */
85 public String getVersion() {
86 return "2.5";
87 }
88
89
90
91 /**
92 * Returns
93 * FT1 (Financial Transaction) - creates it if necessary
94 */
95 public FT1 getFT1() {
96 FT1 retVal = getTyped("FT1", FT1.class);
97 return retVal;
98 }
99
100
101
102
103 /**
104 * Returns
105 * the first repetition of
106 * FINANCIAL_PROCEDURE (a Group object) - creates it if necessary
107 */
108 public DFT_P11_FINANCIAL_PROCEDURE getFINANCIAL_PROCEDURE() {
109 DFT_P11_FINANCIAL_PROCEDURE retVal = getTyped("FINANCIAL_PROCEDURE", DFT_P11_FINANCIAL_PROCEDURE.class);
110 return retVal;
111 }
112
113
114 /**
115 * Returns a specific repetition of
116 * FINANCIAL_PROCEDURE (a Group object) - creates it if necessary
117 *
118 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
119 * @throws HL7Exception if the repetition requested is more than one
120 * greater than the number of existing repetitions.
121 */
122 public DFT_P11_FINANCIAL_PROCEDURE getFINANCIAL_PROCEDURE(int rep) {
123 DFT_P11_FINANCIAL_PROCEDURE retVal = getTyped("FINANCIAL_PROCEDURE", rep, DFT_P11_FINANCIAL_PROCEDURE.class);
124 return retVal;
125 }
126
127 /**
128 * Returns the number of existing repetitions of FINANCIAL_PROCEDURE
129 */
130 public int getFINANCIAL_PROCEDUREReps() {
131 return getReps("FINANCIAL_PROCEDURE");
132 }
133
134 /**
135 * <p>
136 * Returns a non-modifiable List containing all current existing repetitions of FINANCIAL_PROCEDURE.
137 * <p>
138 * <p>
139 * Note that unlike {@link #getFINANCIAL_PROCEDURE()}, this method will not create any reps
140 * if none are already present, so an empty list may be returned.
141 * </p>
142 */
143 public java.util.List<DFT_P11_FINANCIAL_PROCEDURE> getFINANCIAL_PROCEDUREAll() throws HL7Exception {
144 return getAllAsList("FINANCIAL_PROCEDURE", DFT_P11_FINANCIAL_PROCEDURE.class);
145 }
146
147 /**
148 * Inserts a specific repetition of FINANCIAL_PROCEDURE (a Group object)
149 * @see AbstractGroup#insertRepetition(Structure, int)
150 */
151 public void insertFINANCIAL_PROCEDURE(DFT_P11_FINANCIAL_PROCEDURE structure, int rep) throws HL7Exception {
152 super.insertRepetition("FINANCIAL_PROCEDURE", structure, rep);
153 }
154
155
156 /**
157 * Inserts a specific repetition of FINANCIAL_PROCEDURE (a Group object)
158 * @see AbstractGroup#insertRepetition(Structure, int)
159 */
160 public DFT_P11_FINANCIAL_PROCEDURE insertFINANCIAL_PROCEDURE(int rep) throws HL7Exception {
161 return (DFT_P11_FINANCIAL_PROCEDURE)super.insertRepetition("FINANCIAL_PROCEDURE", rep);
162 }
163
164
165 /**
166 * Removes a specific repetition of FINANCIAL_PROCEDURE (a Group object)
167 * @see AbstractGroup#removeRepetition(String, int)
168 */
169 public DFT_P11_FINANCIAL_PROCEDURE removeFINANCIAL_PROCEDURE(int rep) throws HL7Exception {
170 return (DFT_P11_FINANCIAL_PROCEDURE)super.removeRepetition("FINANCIAL_PROCEDURE", rep);
171 }
172
173
174
175 /**
176 * Returns
177 * the first repetition of
178 * FINANCIAL_COMMON_ORDER (a Group object) - creates it if necessary
179 */
180 public DFT_P11_FINANCIAL_COMMON_ORDER getFINANCIAL_COMMON_ORDER() {
181 DFT_P11_FINANCIAL_COMMON_ORDER retVal = getTyped("FINANCIAL_COMMON_ORDER", DFT_P11_FINANCIAL_COMMON_ORDER.class);
182 return retVal;
183 }
184
185
186 /**
187 * Returns a specific repetition of
188 * FINANCIAL_COMMON_ORDER (a Group object) - creates it if necessary
189 *
190 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
191 * @throws HL7Exception if the repetition requested is more than one
192 * greater than the number of existing repetitions.
193 */
194 public DFT_P11_FINANCIAL_COMMON_ORDER getFINANCIAL_COMMON_ORDER(int rep) {
195 DFT_P11_FINANCIAL_COMMON_ORDER retVal = getTyped("FINANCIAL_COMMON_ORDER", rep, DFT_P11_FINANCIAL_COMMON_ORDER.class);
196 return retVal;
197 }
198
199 /**
200 * Returns the number of existing repetitions of FINANCIAL_COMMON_ORDER
201 */
202 public int getFINANCIAL_COMMON_ORDERReps() {
203 return getReps("FINANCIAL_COMMON_ORDER");
204 }
205
206 /**
207 * <p>
208 * Returns a non-modifiable List containing all current existing repetitions of FINANCIAL_COMMON_ORDER.
209 * <p>
210 * <p>
211 * Note that unlike {@link #getFINANCIAL_COMMON_ORDER()}, this method will not create any reps
212 * if none are already present, so an empty list may be returned.
213 * </p>
214 */
215 public java.util.List<DFT_P11_FINANCIAL_COMMON_ORDER> getFINANCIAL_COMMON_ORDERAll() throws HL7Exception {
216 return getAllAsList("FINANCIAL_COMMON_ORDER", DFT_P11_FINANCIAL_COMMON_ORDER.class);
217 }
218
219 /**
220 * Inserts a specific repetition of FINANCIAL_COMMON_ORDER (a Group object)
221 * @see AbstractGroup#insertRepetition(Structure, int)
222 */
223 public void insertFINANCIAL_COMMON_ORDER(DFT_P11_FINANCIAL_COMMON_ORDER structure, int rep) throws HL7Exception {
224 super.insertRepetition("FINANCIAL_COMMON_ORDER", structure, rep);
225 }
226
227
228 /**
229 * Inserts a specific repetition of FINANCIAL_COMMON_ORDER (a Group object)
230 * @see AbstractGroup#insertRepetition(Structure, int)
231 */
232 public DFT_P11_FINANCIAL_COMMON_ORDER insertFINANCIAL_COMMON_ORDER(int rep) throws HL7Exception {
233 return (DFT_P11_FINANCIAL_COMMON_ORDER)super.insertRepetition("FINANCIAL_COMMON_ORDER", rep);
234 }
235
236
237 /**
238 * Removes a specific repetition of FINANCIAL_COMMON_ORDER (a Group object)
239 * @see AbstractGroup#removeRepetition(String, int)
240 */
241 public DFT_P11_FINANCIAL_COMMON_ORDER removeFINANCIAL_COMMON_ORDER(int rep) throws HL7Exception {
242 return (DFT_P11_FINANCIAL_COMMON_ORDER)super.removeRepetition("FINANCIAL_COMMON_ORDER", rep);
243 }
244
245
246
247 /**
248 * Returns
249 * the first repetition of
250 * DG1 (Diagnosis) - creates it if necessary
251 */
252 public DG1 getDG1() {
253 DG1 retVal = getTyped("DG1", DG1.class);
254 return retVal;
255 }
256
257
258 /**
259 * Returns a specific repetition of
260 * DG1 (Diagnosis) - creates it if necessary
261 *
262 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
263 * @throws HL7Exception if the repetition requested is more than one
264 * greater than the number of existing repetitions.
265 */
266 public DG1 getDG1(int rep) {
267 DG1 retVal = getTyped("DG1", rep, DG1.class);
268 return retVal;
269 }
270
271 /**
272 * Returns the number of existing repetitions of DG1
273 */
274 public int getDG1Reps() {
275 return getReps("DG1");
276 }
277
278 /**
279 * <p>
280 * Returns a non-modifiable List containing all current existing repetitions of DG1.
281 * <p>
282 * <p>
283 * Note that unlike {@link #getDG1()}, this method will not create any reps
284 * if none are already present, so an empty list may be returned.
285 * </p>
286 */
287 public java.util.List<DG1> getDG1All() throws HL7Exception {
288 return getAllAsList("DG1", DG1.class);
289 }
290
291 /**
292 * Inserts a specific repetition of DG1 (Diagnosis)
293 * @see AbstractGroup#insertRepetition(Structure, int)
294 */
295 public void insertDG1(DG1 structure, int rep) throws HL7Exception {
296 super.insertRepetition("DG1", structure, rep);
297 }
298
299
300 /**
301 * Inserts a specific repetition of DG1 (Diagnosis)
302 * @see AbstractGroup#insertRepetition(Structure, int)
303 */
304 public DG1 insertDG1(int rep) throws HL7Exception {
305 return (DG1)super.insertRepetition("DG1", rep);
306 }
307
308
309 /**
310 * Removes a specific repetition of DG1 (Diagnosis)
311 * @see AbstractGroup#removeRepetition(String, int)
312 */
313 public DG1 removeDG1(int rep) throws HL7Exception {
314 return (DG1)super.removeRepetition("DG1", rep);
315 }
316
317
318
319 /**
320 * Returns
321 * DRG (Diagnosis Related Group) - creates it if necessary
322 */
323 public DRG getDRG() {
324 DRG retVal = getTyped("DRG", DRG.class);
325 return retVal;
326 }
327
328
329
330
331 /**
332 * Returns
333 * the first repetition of
334 * GT1 (Guarantor) - creates it if necessary
335 */
336 public GT1 getGT1() {
337 GT1 retVal = getTyped("GT1", GT1.class);
338 return retVal;
339 }
340
341
342 /**
343 * Returns a specific repetition of
344 * GT1 (Guarantor) - creates it if necessary
345 *
346 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
347 * @throws HL7Exception if the repetition requested is more than one
348 * greater than the number of existing repetitions.
349 */
350 public GT1 getGT1(int rep) {
351 GT1 retVal = getTyped("GT1", rep, GT1.class);
352 return retVal;
353 }
354
355 /**
356 * Returns the number of existing repetitions of GT1
357 */
358 public int getGT1Reps() {
359 return getReps("GT1");
360 }
361
362 /**
363 * <p>
364 * Returns a non-modifiable List containing all current existing repetitions of GT1.
365 * <p>
366 * <p>
367 * Note that unlike {@link #getGT1()}, this method will not create any reps
368 * if none are already present, so an empty list may be returned.
369 * </p>
370 */
371 public java.util.List<GT1> getGT1All() throws HL7Exception {
372 return getAllAsList("GT1", GT1.class);
373 }
374
375 /**
376 * Inserts a specific repetition of GT1 (Guarantor)
377 * @see AbstractGroup#insertRepetition(Structure, int)
378 */
379 public void insertGT1(GT1 structure, int rep) throws HL7Exception {
380 super.insertRepetition("GT1", structure, rep);
381 }
382
383
384 /**
385 * Inserts a specific repetition of GT1 (Guarantor)
386 * @see AbstractGroup#insertRepetition(Structure, int)
387 */
388 public GT1 insertGT1(int rep) throws HL7Exception {
389 return (GT1)super.insertRepetition("GT1", rep);
390 }
391
392
393 /**
394 * Removes a specific repetition of GT1 (Guarantor)
395 * @see AbstractGroup#removeRepetition(String, int)
396 */
397 public GT1 removeGT1(int rep) throws HL7Exception {
398 return (GT1)super.removeRepetition("GT1", rep);
399 }
400
401
402
403 /**
404 * Returns
405 * the first repetition of
406 * FINANCIAL_INSURANCE (a Group object) - creates it if necessary
407 */
408 public DFT_P11_FINANCIAL_INSURANCE getFINANCIAL_INSURANCE() {
409 DFT_P11_FINANCIAL_INSURANCE retVal = getTyped("FINANCIAL_INSURANCE", DFT_P11_FINANCIAL_INSURANCE.class);
410 return retVal;
411 }
412
413
414 /**
415 * Returns a specific repetition of
416 * FINANCIAL_INSURANCE (a Group object) - creates it if necessary
417 *
418 * @param rep The repetition index (0-indexed, i.e. the first repetition is at index 0)
419 * @throws HL7Exception if the repetition requested is more than one
420 * greater than the number of existing repetitions.
421 */
422 public DFT_P11_FINANCIAL_INSURANCE getFINANCIAL_INSURANCE(int rep) {
423 DFT_P11_FINANCIAL_INSURANCE retVal = getTyped("FINANCIAL_INSURANCE", rep, DFT_P11_FINANCIAL_INSURANCE.class);
424 return retVal;
425 }
426
427 /**
428 * Returns the number of existing repetitions of FINANCIAL_INSURANCE
429 */
430 public int getFINANCIAL_INSURANCEReps() {
431 return getReps("FINANCIAL_INSURANCE");
432 }
433
434 /**
435 * <p>
436 * Returns a non-modifiable List containing all current existing repetitions of FINANCIAL_INSURANCE.
437 * <p>
438 * <p>
439 * Note that unlike {@link #getFINANCIAL_INSURANCE()}, this method will not create any reps
440 * if none are already present, so an empty list may be returned.
441 * </p>
442 */
443 public java.util.List<DFT_P11_FINANCIAL_INSURANCE> getFINANCIAL_INSURANCEAll() throws HL7Exception {
444 return getAllAsList("FINANCIAL_INSURANCE", DFT_P11_FINANCIAL_INSURANCE.class);
445 }
446
447 /**
448 * Inserts a specific repetition of FINANCIAL_INSURANCE (a Group object)
449 * @see AbstractGroup#insertRepetition(Structure, int)
450 */
451 public void insertFINANCIAL_INSURANCE(DFT_P11_FINANCIAL_INSURANCE structure, int rep) throws HL7Exception {
452 super.insertRepetition("FINANCIAL_INSURANCE", structure, rep);
453 }
454
455
456 /**
457 * Inserts a specific repetition of FINANCIAL_INSURANCE (a Group object)
458 * @see AbstractGroup#insertRepetition(Structure, int)
459 */
460 public DFT_P11_FINANCIAL_INSURANCE insertFINANCIAL_INSURANCE(int rep) throws HL7Exception {
461 return (DFT_P11_FINANCIAL_INSURANCE)super.insertRepetition("FINANCIAL_INSURANCE", rep);
462 }
463
464
465 /**
466 * Removes a specific repetition of FINANCIAL_INSURANCE (a Group object)
467 * @see AbstractGroup#removeRepetition(String, int)
468 */
469 public DFT_P11_FINANCIAL_INSURANCE removeFINANCIAL_INSURANCE(int rep) throws HL7Exception {
470 return (DFT_P11_FINANCIAL_INSURANCE)super.removeRepetition("FINANCIAL_INSURANCE", rep);
471 }
472
473
474
475 }
476