Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||
OBX |
|
| 1.4382022471910112;1.438 |
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.singledt.conf.segment; | |
35 | ||
36 | // import ca.uhn.hl7v2.test.singledt.conf.group.*; | |
37 | import ca.uhn.hl7v2.model.v25.datatype.*; | |
38 | import ca.uhn.hl7v2.HL7Exception; | |
39 | import ca.uhn.hl7v2.parser.ModelClassFactory; | |
40 | import ca.uhn.hl7v2.parser.DefaultModelClassFactory; | |
41 | import ca.uhn.hl7v2.model.AbstractMessage; | |
42 | import ca.uhn.hl7v2.model.Group; | |
43 | import ca.uhn.hl7v2.model.Type; | |
44 | import ca.uhn.hl7v2.model.AbstractSegment; | |
45 | import ca.uhn.hl7v2.model.Varies; | |
46 | ||
47 | ||
48 | /** | |
49 | *<p>Represents an HL7 OBX message segment (Observation/Result). | |
50 | * This segment has the following fields:</p> | |
51 | * <ul> | |
52 | * <li>OBX-1: Set ID - OBX (SI) <b>optional </b> | |
53 | * <li>OBX-2: Value Type (ID) <b>optional </b> | |
54 | * <li>OBX-3: Observation Identifier (CE) <b> </b> | |
55 | * <li>OBX-4: Observation Sub-ID (ST) <b>optional </b> | |
56 | * <li>OBX-5: Observation Value (Varies) <b>optional repeating</b> | |
57 | * <li>OBX-6: Units (CE) <b>optional </b> | |
58 | * <li>OBX-7: References Range (ST) <b>optional </b> | |
59 | * <li>OBX-8: Abnormal Flags (IS) <b>optional repeating</b> | |
60 | * <li>OBX-9: Probability (NM) <b>optional </b> | |
61 | * <li>OBX-10: Nature of Abnormal Test (ID) <b>optional repeating</b> | |
62 | * <li>OBX-11: Observation Result Status (ID) <b> </b> | |
63 | * <li>OBX-12: Effective Date of Reference Range (TS) <b>optional </b> | |
64 | * <li>OBX-13: User Defined Access Checks (ST) <b>optional </b> | |
65 | * <li>OBX-14: Date/Time of the Observation (TS) <b>optional </b> | |
66 | * <li>OBX-15: Producer's ID (CE) <b>optional </b> | |
67 | * <li>OBX-16: Responsible Observer (XCN) <b>optional repeating</b> | |
68 | * <li>OBX-17: Observation Method (CE) <b>optional repeating</b> | |
69 | * <li>OBX-18: Equipment Instance Identifier (EI) <b>optional repeating</b> | |
70 | * <li>OBX-19: Date/Time of the Analysis (TS) <b>optional </b> | |
71 | * </ul> | |
72 | */ | |
73 | @SuppressWarnings("unused") | |
74 | public class OBX extends AbstractSegment { | |
75 | ||
76 | /** | |
77 | * Creates a new OBX segment | |
78 | */ | |
79 | public OBX(Group parent, ModelClassFactory factory) { | |
80 | 10 | super(parent, factory); |
81 | 10 | init(factory); |
82 | 10 | } |
83 | ||
84 | private void init(ModelClassFactory factory) { | |
85 | try { | |
86 | 10 | this.add(SI.class, false, 1, 4, new Object[]{ getMessage() }, "Set ID - OBX"); |
87 | 10 | this.add(ID.class, false, 1, 2, new Object[]{ getMessage(), new Integer(125) }, "Value Type"); |
88 | 10 | this.add(CE.class, true, 1, 478, new Object[]{ getMessage() }, "Observation Identifier"); |
89 | 10 | this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "Observation Sub-ID"); |
90 | 10 | this.add(Varies.class, false, -1, 99999, new Object[]{ getMessage() }, "Observation Value"); |
91 | 10 | this.add(CE.class, false, 1, 478, new Object[]{ getMessage() }, "Units"); |
92 | 10 | this.add(ST.class, false, 1, 60, new Object[]{ getMessage() }, "References Range"); |
93 | 10 | this.add(IS.class, false, -1, 5, new Object[]{ getMessage(), new Integer(78) }, "Abnormal Flags"); |
94 | 10 | this.add(NM.class, false, 1, 5, new Object[]{ getMessage() }, "Probability"); |
95 | 10 | this.add(ID.class, false, -1, 2, new Object[]{ getMessage(), new Integer(80) }, "Nature of Abnormal Test"); |
96 | 10 | this.add(ID.class, true, 1, 1, new Object[]{ getMessage(), new Integer(85) }, "Observation Result Status"); |
97 | 10 | this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Effective Date of Reference Range"); |
98 | 10 | this.add(ST.class, false, 1, 20, new Object[]{ getMessage() }, "User Defined Access Checks"); |
99 | 10 | this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of the Observation"); |
100 | 10 | this.add(CE.class, false, 1, 478, new Object[]{ getMessage() }, "Producer's ID"); |
101 | 10 | this.add(XCN.class, false, -1, 309, new Object[]{ getMessage() }, "Responsible Observer"); |
102 | 10 | this.add(CE.class, false, -1, 478, new Object[]{ getMessage() }, "Observation Method"); |
103 | 10 | this.add(EI.class, false, -1, 424, new Object[]{ getMessage() }, "Equipment Instance Identifier"); |
104 | 10 | this.add(TS.class, false, 1, 26, new Object[]{ getMessage() }, "Date/Time of the Analysis"); |
105 | 0 | } catch(HL7Exception e) { |
106 | 0 | log.error("Unexpected error creating OBX - this is probably a bug in the source code generator.", e); |
107 | 10 | } |
108 | 10 | } |
109 | ||
110 | ||
111 | ||
112 | /** | |
113 | * Returns | |
114 | * OBX-1: "Set ID - OBX" - creates it if necessary | |
115 | */ | |
116 | public SI getSetIDOBX() { | |
117 | 20 | SI retVal = this.getTypedField(1, 0); |
118 | 20 | return retVal; |
119 | } | |
120 | ||
121 | /** | |
122 | * Returns | |
123 | * OBX-1: "Set ID - OBX" - creates it if necessary | |
124 | */ | |
125 | public SI getObx1_SetIDOBX() { | |
126 | 0 | SI retVal = this.getTypedField(1, 0); |
127 | 0 | return retVal; |
128 | } | |
129 | ||
130 | ||
131 | ||
132 | /** | |
133 | * Returns | |
134 | * OBX-2: "Value Type" - creates it if necessary | |
135 | */ | |
136 | public ID getValueType() { | |
137 | 0 | ID retVal = this.getTypedField(2, 0); |
138 | 0 | return retVal; |
139 | } | |
140 | ||
141 | /** | |
142 | * Returns | |
143 | * OBX-2: "Value Type" - creates it if necessary | |
144 | */ | |
145 | public ID getObx2_ValueType() { | |
146 | 0 | ID retVal = this.getTypedField(2, 0); |
147 | 0 | return retVal; |
148 | } | |
149 | ||
150 | ||
151 | ||
152 | /** | |
153 | * Returns | |
154 | * OBX-3: "Observation Identifier" - creates it if necessary | |
155 | */ | |
156 | public CE getObservationIdentifier() { | |
157 | 0 | CE retVal = this.getTypedField(3, 0); |
158 | 0 | return retVal; |
159 | } | |
160 | ||
161 | /** | |
162 | * Returns | |
163 | * OBX-3: "Observation Identifier" - creates it if necessary | |
164 | */ | |
165 | public CE getObx3_ObservationIdentifier() { | |
166 | 0 | CE retVal = this.getTypedField(3, 0); |
167 | 0 | return retVal; |
168 | } | |
169 | ||
170 | ||
171 | ||
172 | /** | |
173 | * Returns | |
174 | * OBX-4: "Observation Sub-ID" - creates it if necessary | |
175 | */ | |
176 | public ST getObservationSubID() { | |
177 | 0 | ST retVal = this.getTypedField(4, 0); |
178 | 0 | return retVal; |
179 | } | |
180 | ||
181 | /** | |
182 | * Returns | |
183 | * OBX-4: "Observation Sub-ID" - creates it if necessary | |
184 | */ | |
185 | public ST getObx4_ObservationSubID() { | |
186 | 0 | ST retVal = this.getTypedField(4, 0); |
187 | 0 | return retVal; |
188 | } | |
189 | ||
190 | ||
191 | /** | |
192 | * Returns all repetitions of Observation Value (OBX-5). | |
193 | */ | |
194 | public Varies[] getObservationValue() { | |
195 | 0 | Varies[] retVal = this.getTypedField(5, new Varies[0]); |
196 | 0 | return retVal; |
197 | } | |
198 | ||
199 | ||
200 | /** | |
201 | * Returns all repetitions of Observation Value (OBX-5). | |
202 | */ | |
203 | public Varies[] getObx5_ObservationValue() { | |
204 | 0 | Varies[] retVal = this.getTypedField(5, new Varies[0]); |
205 | 0 | return retVal; |
206 | } | |
207 | ||
208 | ||
209 | /** | |
210 | * Returns a count of the current number of repetitions of Observation Value (OBX-5). | |
211 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
212 | * it will return zero. | |
213 | */ | |
214 | public int getObservationValueReps() { | |
215 | 0 | return this.getReps(5); |
216 | } | |
217 | ||
218 | ||
219 | /** | |
220 | * Returns a specific repetition of | |
221 | * OBX-5: "Observation Value" - creates it if necessary | |
222 | * | |
223 | * @param rep The repetition index (0-indexed) | |
224 | */ | |
225 | public Varies getObservationValue(int rep) { | |
226 | 0 | Varies retVal = this.getTypedField(5, rep); |
227 | 0 | return retVal; |
228 | } | |
229 | ||
230 | /** | |
231 | * Returns a specific repetition of | |
232 | * OBX-5: "Observation Value" - creates it if necessary | |
233 | * | |
234 | * @param rep The repetition index (0-indexed) | |
235 | */ | |
236 | public Varies getObx5_ObservationValue(int rep) { | |
237 | 0 | Varies retVal = this.getTypedField(5, rep); |
238 | 0 | return retVal; |
239 | } | |
240 | ||
241 | /** | |
242 | * Returns a count of the current number of repetitions of Observation Value (OBX-5). | |
243 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
244 | * it will return zero. | |
245 | */ | |
246 | public int getObx5_ObservationValueReps() { | |
247 | 0 | return this.getReps(5); |
248 | } | |
249 | ||
250 | ||
251 | /** | |
252 | * Inserts a repetition of | |
253 | * OBX-5: "Observation Value" at a specific index | |
254 | * | |
255 | * @param rep The repetition index (0-indexed) | |
256 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
257 | */ | |
258 | public Varies insertObservationValue(int rep) throws HL7Exception { | |
259 | 0 | return (Varies) super.insertRepetition(5, rep); |
260 | } | |
261 | ||
262 | ||
263 | /** | |
264 | * Inserts a repetition of | |
265 | * OBX-5: "Observation Value" at a specific index | |
266 | * | |
267 | * @param rep The repetition index (0-indexed) | |
268 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
269 | */ | |
270 | public Varies insertObx5_ObservationValue(int rep) throws HL7Exception { | |
271 | 0 | return (Varies) super.insertRepetition(5, rep); |
272 | } | |
273 | ||
274 | ||
275 | /** | |
276 | * Removes a repetition of | |
277 | * OBX-5: "Observation Value" at a specific index | |
278 | * | |
279 | * @param rep The repetition index (0-indexed) | |
280 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
281 | */ | |
282 | public Varies removeObservationValue(int rep) throws HL7Exception { | |
283 | 0 | return (Varies) super.removeRepetition(5, rep); |
284 | } | |
285 | ||
286 | ||
287 | /** | |
288 | * Removes a repetition of | |
289 | * OBX-5: "Observation Value" at a specific index | |
290 | * | |
291 | * @param rep The repetition index (0-indexed) | |
292 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
293 | */ | |
294 | public Varies removeObx5_ObservationValue(int rep) throws HL7Exception { | |
295 | 0 | return (Varies) super.removeRepetition(5, rep); |
296 | } | |
297 | ||
298 | ||
299 | ||
300 | ||
301 | /** | |
302 | * Returns | |
303 | * OBX-6: "Units" - creates it if necessary | |
304 | */ | |
305 | public CE getUnits() { | |
306 | 0 | CE retVal = this.getTypedField(6, 0); |
307 | 0 | return retVal; |
308 | } | |
309 | ||
310 | /** | |
311 | * Returns | |
312 | * OBX-6: "Units" - creates it if necessary | |
313 | */ | |
314 | public CE getObx6_Units() { | |
315 | 0 | CE retVal = this.getTypedField(6, 0); |
316 | 0 | return retVal; |
317 | } | |
318 | ||
319 | ||
320 | ||
321 | /** | |
322 | * Returns | |
323 | * OBX-7: "References Range" - creates it if necessary | |
324 | */ | |
325 | public ST getReferencesRange() { | |
326 | 0 | ST retVal = this.getTypedField(7, 0); |
327 | 0 | return retVal; |
328 | } | |
329 | ||
330 | /** | |
331 | * Returns | |
332 | * OBX-7: "References Range" - creates it if necessary | |
333 | */ | |
334 | public ST getObx7_ReferencesRange() { | |
335 | 0 | ST retVal = this.getTypedField(7, 0); |
336 | 0 | return retVal; |
337 | } | |
338 | ||
339 | ||
340 | /** | |
341 | * Returns all repetitions of Abnormal Flags (OBX-8). | |
342 | */ | |
343 | public IS[] getAbnormalFlags() { | |
344 | 0 | IS[] retVal = this.getTypedField(8, new IS[0]); |
345 | 0 | return retVal; |
346 | } | |
347 | ||
348 | ||
349 | /** | |
350 | * Returns all repetitions of Abnormal Flags (OBX-8). | |
351 | */ | |
352 | public IS[] getObx8_AbnormalFlags() { | |
353 | 0 | IS[] retVal = this.getTypedField(8, new IS[0]); |
354 | 0 | return retVal; |
355 | } | |
356 | ||
357 | ||
358 | /** | |
359 | * Returns a count of the current number of repetitions of Abnormal Flags (OBX-8). | |
360 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
361 | * it will return zero. | |
362 | */ | |
363 | public int getAbnormalFlagsReps() { | |
364 | 0 | return this.getReps(8); |
365 | } | |
366 | ||
367 | ||
368 | /** | |
369 | * Returns a specific repetition of | |
370 | * OBX-8: "Abnormal Flags" - creates it if necessary | |
371 | * | |
372 | * @param rep The repetition index (0-indexed) | |
373 | */ | |
374 | public IS getAbnormalFlags(int rep) { | |
375 | 0 | IS retVal = this.getTypedField(8, rep); |
376 | 0 | return retVal; |
377 | } | |
378 | ||
379 | /** | |
380 | * Returns a specific repetition of | |
381 | * OBX-8: "Abnormal Flags" - creates it if necessary | |
382 | * | |
383 | * @param rep The repetition index (0-indexed) | |
384 | */ | |
385 | public IS getObx8_AbnormalFlags(int rep) { | |
386 | 0 | IS retVal = this.getTypedField(8, rep); |
387 | 0 | return retVal; |
388 | } | |
389 | ||
390 | /** | |
391 | * Returns a count of the current number of repetitions of Abnormal Flags (OBX-8). | |
392 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
393 | * it will return zero. | |
394 | */ | |
395 | public int getObx8_AbnormalFlagsReps() { | |
396 | 0 | return this.getReps(8); |
397 | } | |
398 | ||
399 | ||
400 | /** | |
401 | * Inserts a repetition of | |
402 | * OBX-8: "Abnormal Flags" at a specific index | |
403 | * | |
404 | * @param rep The repetition index (0-indexed) | |
405 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
406 | */ | |
407 | public IS insertAbnormalFlags(int rep) throws HL7Exception { | |
408 | 0 | return (IS) super.insertRepetition(8, rep); |
409 | } | |
410 | ||
411 | ||
412 | /** | |
413 | * Inserts a repetition of | |
414 | * OBX-8: "Abnormal Flags" at a specific index | |
415 | * | |
416 | * @param rep The repetition index (0-indexed) | |
417 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
418 | */ | |
419 | public IS insertObx8_AbnormalFlags(int rep) throws HL7Exception { | |
420 | 0 | return (IS) super.insertRepetition(8, rep); |
421 | } | |
422 | ||
423 | ||
424 | /** | |
425 | * Removes a repetition of | |
426 | * OBX-8: "Abnormal Flags" at a specific index | |
427 | * | |
428 | * @param rep The repetition index (0-indexed) | |
429 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
430 | */ | |
431 | public IS removeAbnormalFlags(int rep) throws HL7Exception { | |
432 | 0 | return (IS) super.removeRepetition(8, rep); |
433 | } | |
434 | ||
435 | ||
436 | /** | |
437 | * Removes a repetition of | |
438 | * OBX-8: "Abnormal Flags" at a specific index | |
439 | * | |
440 | * @param rep The repetition index (0-indexed) | |
441 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
442 | */ | |
443 | public IS removeObx8_AbnormalFlags(int rep) throws HL7Exception { | |
444 | 0 | return (IS) super.removeRepetition(8, rep); |
445 | } | |
446 | ||
447 | ||
448 | ||
449 | ||
450 | /** | |
451 | * Returns | |
452 | * OBX-9: "Probability" - creates it if necessary | |
453 | */ | |
454 | public NM getProbability() { | |
455 | 0 | NM retVal = this.getTypedField(9, 0); |
456 | 0 | return retVal; |
457 | } | |
458 | ||
459 | /** | |
460 | * Returns | |
461 | * OBX-9: "Probability" - creates it if necessary | |
462 | */ | |
463 | public NM getObx9_Probability() { | |
464 | 0 | NM retVal = this.getTypedField(9, 0); |
465 | 0 | return retVal; |
466 | } | |
467 | ||
468 | ||
469 | /** | |
470 | * Returns all repetitions of Nature of Abnormal Test (OBX-10). | |
471 | */ | |
472 | public ID[] getNatureOfAbnormalTest() { | |
473 | 0 | ID[] retVal = this.getTypedField(10, new ID[0]); |
474 | 0 | return retVal; |
475 | } | |
476 | ||
477 | ||
478 | /** | |
479 | * Returns all repetitions of Nature of Abnormal Test (OBX-10). | |
480 | */ | |
481 | public ID[] getObx10_NatureOfAbnormalTest() { | |
482 | 0 | ID[] retVal = this.getTypedField(10, new ID[0]); |
483 | 0 | return retVal; |
484 | } | |
485 | ||
486 | ||
487 | /** | |
488 | * Returns a count of the current number of repetitions of Nature of Abnormal Test (OBX-10). | |
489 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
490 | * it will return zero. | |
491 | */ | |
492 | public int getNatureOfAbnormalTestReps() { | |
493 | 0 | return this.getReps(10); |
494 | } | |
495 | ||
496 | ||
497 | /** | |
498 | * Returns a specific repetition of | |
499 | * OBX-10: "Nature of Abnormal Test" - creates it if necessary | |
500 | * | |
501 | * @param rep The repetition index (0-indexed) | |
502 | */ | |
503 | public ID getNatureOfAbnormalTest(int rep) { | |
504 | 0 | ID retVal = this.getTypedField(10, rep); |
505 | 0 | return retVal; |
506 | } | |
507 | ||
508 | /** | |
509 | * Returns a specific repetition of | |
510 | * OBX-10: "Nature of Abnormal Test" - creates it if necessary | |
511 | * | |
512 | * @param rep The repetition index (0-indexed) | |
513 | */ | |
514 | public ID getObx10_NatureOfAbnormalTest(int rep) { | |
515 | 0 | ID retVal = this.getTypedField(10, rep); |
516 | 0 | return retVal; |
517 | } | |
518 | ||
519 | /** | |
520 | * Returns a count of the current number of repetitions of Nature of Abnormal Test (OBX-10). | |
521 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
522 | * it will return zero. | |
523 | */ | |
524 | public int getObx10_NatureOfAbnormalTestReps() { | |
525 | 0 | return this.getReps(10); |
526 | } | |
527 | ||
528 | ||
529 | /** | |
530 | * Inserts a repetition of | |
531 | * OBX-10: "Nature of Abnormal Test" at a specific index | |
532 | * | |
533 | * @param rep The repetition index (0-indexed) | |
534 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
535 | */ | |
536 | public ID insertNatureOfAbnormalTest(int rep) throws HL7Exception { | |
537 | 0 | return (ID) super.insertRepetition(10, rep); |
538 | } | |
539 | ||
540 | ||
541 | /** | |
542 | * Inserts a repetition of | |
543 | * OBX-10: "Nature of Abnormal Test" at a specific index | |
544 | * | |
545 | * @param rep The repetition index (0-indexed) | |
546 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
547 | */ | |
548 | public ID insertObx10_NatureOfAbnormalTest(int rep) throws HL7Exception { | |
549 | 0 | return (ID) super.insertRepetition(10, rep); |
550 | } | |
551 | ||
552 | ||
553 | /** | |
554 | * Removes a repetition of | |
555 | * OBX-10: "Nature of Abnormal Test" at a specific index | |
556 | * | |
557 | * @param rep The repetition index (0-indexed) | |
558 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
559 | */ | |
560 | public ID removeNatureOfAbnormalTest(int rep) throws HL7Exception { | |
561 | 0 | return (ID) super.removeRepetition(10, rep); |
562 | } | |
563 | ||
564 | ||
565 | /** | |
566 | * Removes a repetition of | |
567 | * OBX-10: "Nature of Abnormal Test" at a specific index | |
568 | * | |
569 | * @param rep The repetition index (0-indexed) | |
570 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
571 | */ | |
572 | public ID removeObx10_NatureOfAbnormalTest(int rep) throws HL7Exception { | |
573 | 0 | return (ID) super.removeRepetition(10, rep); |
574 | } | |
575 | ||
576 | ||
577 | ||
578 | ||
579 | /** | |
580 | * Returns | |
581 | * OBX-11: "Observation Result Status" - creates it if necessary | |
582 | */ | |
583 | public ID getObservationResultStatus() { | |
584 | 0 | ID retVal = this.getTypedField(11, 0); |
585 | 0 | return retVal; |
586 | } | |
587 | ||
588 | /** | |
589 | * Returns | |
590 | * OBX-11: "Observation Result Status" - creates it if necessary | |
591 | */ | |
592 | public ID getObx11_ObservationResultStatus() { | |
593 | 0 | ID retVal = this.getTypedField(11, 0); |
594 | 0 | return retVal; |
595 | } | |
596 | ||
597 | ||
598 | ||
599 | /** | |
600 | * Returns | |
601 | * OBX-12: "Effective Date of Reference Range" - creates it if necessary | |
602 | */ | |
603 | public TS getEffectiveDateOfReferenceRange() { | |
604 | 0 | TS retVal = this.getTypedField(12, 0); |
605 | 0 | return retVal; |
606 | } | |
607 | ||
608 | /** | |
609 | * Returns | |
610 | * OBX-12: "Effective Date of Reference Range" - creates it if necessary | |
611 | */ | |
612 | public TS getObx12_EffectiveDateOfReferenceRange() { | |
613 | 0 | TS retVal = this.getTypedField(12, 0); |
614 | 0 | return retVal; |
615 | } | |
616 | ||
617 | ||
618 | ||
619 | /** | |
620 | * Returns | |
621 | * OBX-13: "User Defined Access Checks" - creates it if necessary | |
622 | */ | |
623 | public ST getUserDefinedAccessChecks() { | |
624 | 0 | ST retVal = this.getTypedField(13, 0); |
625 | 0 | return retVal; |
626 | } | |
627 | ||
628 | /** | |
629 | * Returns | |
630 | * OBX-13: "User Defined Access Checks" - creates it if necessary | |
631 | */ | |
632 | public ST getObx13_UserDefinedAccessChecks() { | |
633 | 0 | ST retVal = this.getTypedField(13, 0); |
634 | 0 | return retVal; |
635 | } | |
636 | ||
637 | ||
638 | ||
639 | /** | |
640 | * Returns | |
641 | * OBX-14: "Date/Time of the Observation" - creates it if necessary | |
642 | */ | |
643 | public TS getDateTimeOfTheObservation() { | |
644 | 0 | TS retVal = this.getTypedField(14, 0); |
645 | 0 | return retVal; |
646 | } | |
647 | ||
648 | /** | |
649 | * Returns | |
650 | * OBX-14: "Date/Time of the Observation" - creates it if necessary | |
651 | */ | |
652 | public TS getObx14_DateTimeOfTheObservation() { | |
653 | 0 | TS retVal = this.getTypedField(14, 0); |
654 | 0 | return retVal; |
655 | } | |
656 | ||
657 | ||
658 | ||
659 | /** | |
660 | * Returns | |
661 | * OBX-15: "Producer's ID" - creates it if necessary | |
662 | */ | |
663 | public CE getProducerSID() { | |
664 | 0 | CE retVal = this.getTypedField(15, 0); |
665 | 0 | return retVal; |
666 | } | |
667 | ||
668 | /** | |
669 | * Returns | |
670 | * OBX-15: "Producer's ID" - creates it if necessary | |
671 | */ | |
672 | public CE getObx15_ProducerSID() { | |
673 | 0 | CE retVal = this.getTypedField(15, 0); |
674 | 0 | return retVal; |
675 | } | |
676 | ||
677 | ||
678 | /** | |
679 | * Returns all repetitions of Responsible Observer (OBX-16). | |
680 | */ | |
681 | public XCN[] getResponsibleObserver() { | |
682 | 0 | XCN[] retVal = this.getTypedField(16, new XCN[0]); |
683 | 0 | return retVal; |
684 | } | |
685 | ||
686 | ||
687 | /** | |
688 | * Returns all repetitions of Responsible Observer (OBX-16). | |
689 | */ | |
690 | public XCN[] getObx16_ResponsibleObserver() { | |
691 | 0 | XCN[] retVal = this.getTypedField(16, new XCN[0]); |
692 | 0 | return retVal; |
693 | } | |
694 | ||
695 | ||
696 | /** | |
697 | * Returns a count of the current number of repetitions of Responsible Observer (OBX-16). | |
698 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
699 | * it will return zero. | |
700 | */ | |
701 | public int getResponsibleObserverReps() { | |
702 | 0 | return this.getReps(16); |
703 | } | |
704 | ||
705 | ||
706 | /** | |
707 | * Returns a specific repetition of | |
708 | * OBX-16: "Responsible Observer" - creates it if necessary | |
709 | * | |
710 | * @param rep The repetition index (0-indexed) | |
711 | */ | |
712 | public XCN getResponsibleObserver(int rep) { | |
713 | 0 | XCN retVal = this.getTypedField(16, rep); |
714 | 0 | return retVal; |
715 | } | |
716 | ||
717 | /** | |
718 | * Returns a specific repetition of | |
719 | * OBX-16: "Responsible Observer" - creates it if necessary | |
720 | * | |
721 | * @param rep The repetition index (0-indexed) | |
722 | */ | |
723 | public XCN getObx16_ResponsibleObserver(int rep) { | |
724 | 0 | XCN retVal = this.getTypedField(16, rep); |
725 | 0 | return retVal; |
726 | } | |
727 | ||
728 | /** | |
729 | * Returns a count of the current number of repetitions of Responsible Observer (OBX-16). | |
730 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
731 | * it will return zero. | |
732 | */ | |
733 | public int getObx16_ResponsibleObserverReps() { | |
734 | 0 | return this.getReps(16); |
735 | } | |
736 | ||
737 | ||
738 | /** | |
739 | * Inserts a repetition of | |
740 | * OBX-16: "Responsible Observer" at a specific index | |
741 | * | |
742 | * @param rep The repetition index (0-indexed) | |
743 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
744 | */ | |
745 | public XCN insertResponsibleObserver(int rep) throws HL7Exception { | |
746 | 0 | return (XCN) super.insertRepetition(16, rep); |
747 | } | |
748 | ||
749 | ||
750 | /** | |
751 | * Inserts a repetition of | |
752 | * OBX-16: "Responsible Observer" at a specific index | |
753 | * | |
754 | * @param rep The repetition index (0-indexed) | |
755 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
756 | */ | |
757 | public XCN insertObx16_ResponsibleObserver(int rep) throws HL7Exception { | |
758 | 0 | return (XCN) super.insertRepetition(16, rep); |
759 | } | |
760 | ||
761 | ||
762 | /** | |
763 | * Removes a repetition of | |
764 | * OBX-16: "Responsible Observer" at a specific index | |
765 | * | |
766 | * @param rep The repetition index (0-indexed) | |
767 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
768 | */ | |
769 | public XCN removeResponsibleObserver(int rep) throws HL7Exception { | |
770 | 0 | return (XCN) super.removeRepetition(16, rep); |
771 | } | |
772 | ||
773 | ||
774 | /** | |
775 | * Removes a repetition of | |
776 | * OBX-16: "Responsible Observer" at a specific index | |
777 | * | |
778 | * @param rep The repetition index (0-indexed) | |
779 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
780 | */ | |
781 | public XCN removeObx16_ResponsibleObserver(int rep) throws HL7Exception { | |
782 | 0 | return (XCN) super.removeRepetition(16, rep); |
783 | } | |
784 | ||
785 | ||
786 | ||
787 | /** | |
788 | * Returns all repetitions of Observation Method (OBX-17). | |
789 | */ | |
790 | public CE[] getObservationMethod() { | |
791 | 0 | CE[] retVal = this.getTypedField(17, new CE[0]); |
792 | 0 | return retVal; |
793 | } | |
794 | ||
795 | ||
796 | /** | |
797 | * Returns all repetitions of Observation Method (OBX-17). | |
798 | */ | |
799 | public CE[] getObx17_ObservationMethod() { | |
800 | 0 | CE[] retVal = this.getTypedField(17, new CE[0]); |
801 | 0 | return retVal; |
802 | } | |
803 | ||
804 | ||
805 | /** | |
806 | * Returns a count of the current number of repetitions of Observation Method (OBX-17). | |
807 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
808 | * it will return zero. | |
809 | */ | |
810 | public int getObservationMethodReps() { | |
811 | 0 | return this.getReps(17); |
812 | } | |
813 | ||
814 | ||
815 | /** | |
816 | * Returns a specific repetition of | |
817 | * OBX-17: "Observation Method" - creates it if necessary | |
818 | * | |
819 | * @param rep The repetition index (0-indexed) | |
820 | */ | |
821 | public CE getObservationMethod(int rep) { | |
822 | 0 | CE retVal = this.getTypedField(17, rep); |
823 | 0 | return retVal; |
824 | } | |
825 | ||
826 | /** | |
827 | * Returns a specific repetition of | |
828 | * OBX-17: "Observation Method" - creates it if necessary | |
829 | * | |
830 | * @param rep The repetition index (0-indexed) | |
831 | */ | |
832 | public CE getObx17_ObservationMethod(int rep) { | |
833 | 0 | CE retVal = this.getTypedField(17, rep); |
834 | 0 | return retVal; |
835 | } | |
836 | ||
837 | /** | |
838 | * Returns a count of the current number of repetitions of Observation Method (OBX-17). | |
839 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
840 | * it will return zero. | |
841 | */ | |
842 | public int getObx17_ObservationMethodReps() { | |
843 | 0 | return this.getReps(17); |
844 | } | |
845 | ||
846 | ||
847 | /** | |
848 | * Inserts a repetition of | |
849 | * OBX-17: "Observation Method" at a specific index | |
850 | * | |
851 | * @param rep The repetition index (0-indexed) | |
852 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
853 | */ | |
854 | public CE insertObservationMethod(int rep) throws HL7Exception { | |
855 | 0 | return (CE) super.insertRepetition(17, rep); |
856 | } | |
857 | ||
858 | ||
859 | /** | |
860 | * Inserts a repetition of | |
861 | * OBX-17: "Observation Method" at a specific index | |
862 | * | |
863 | * @param rep The repetition index (0-indexed) | |
864 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
865 | */ | |
866 | public CE insertObx17_ObservationMethod(int rep) throws HL7Exception { | |
867 | 0 | return (CE) super.insertRepetition(17, rep); |
868 | } | |
869 | ||
870 | ||
871 | /** | |
872 | * Removes a repetition of | |
873 | * OBX-17: "Observation Method" at a specific index | |
874 | * | |
875 | * @param rep The repetition index (0-indexed) | |
876 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
877 | */ | |
878 | public CE removeObservationMethod(int rep) throws HL7Exception { | |
879 | 0 | return (CE) super.removeRepetition(17, rep); |
880 | } | |
881 | ||
882 | ||
883 | /** | |
884 | * Removes a repetition of | |
885 | * OBX-17: "Observation Method" at a specific index | |
886 | * | |
887 | * @param rep The repetition index (0-indexed) | |
888 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
889 | */ | |
890 | public CE removeObx17_ObservationMethod(int rep) throws HL7Exception { | |
891 | 0 | return (CE) super.removeRepetition(17, rep); |
892 | } | |
893 | ||
894 | ||
895 | ||
896 | /** | |
897 | * Returns all repetitions of Equipment Instance Identifier (OBX-18). | |
898 | */ | |
899 | public EI[] getEquipmentInstanceIdentifier() { | |
900 | 0 | EI[] retVal = this.getTypedField(18, new EI[0]); |
901 | 0 | return retVal; |
902 | } | |
903 | ||
904 | ||
905 | /** | |
906 | * Returns all repetitions of Equipment Instance Identifier (OBX-18). | |
907 | */ | |
908 | public EI[] getObx18_EquipmentInstanceIdentifier() { | |
909 | 0 | EI[] retVal = this.getTypedField(18, new EI[0]); |
910 | 0 | return retVal; |
911 | } | |
912 | ||
913 | ||
914 | /** | |
915 | * Returns a count of the current number of repetitions of Equipment Instance Identifier (OBX-18). | |
916 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
917 | * it will return zero. | |
918 | */ | |
919 | public int getEquipmentInstanceIdentifierReps() { | |
920 | 0 | return this.getReps(18); |
921 | } | |
922 | ||
923 | ||
924 | /** | |
925 | * Returns a specific repetition of | |
926 | * OBX-18: "Equipment Instance Identifier" - creates it if necessary | |
927 | * | |
928 | * @param rep The repetition index (0-indexed) | |
929 | */ | |
930 | public EI getEquipmentInstanceIdentifier(int rep) { | |
931 | 0 | EI retVal = this.getTypedField(18, rep); |
932 | 0 | return retVal; |
933 | } | |
934 | ||
935 | /** | |
936 | * Returns a specific repetition of | |
937 | * OBX-18: "Equipment Instance Identifier" - creates it if necessary | |
938 | * | |
939 | * @param rep The repetition index (0-indexed) | |
940 | */ | |
941 | public EI getObx18_EquipmentInstanceIdentifier(int rep) { | |
942 | 0 | EI retVal = this.getTypedField(18, rep); |
943 | 0 | return retVal; |
944 | } | |
945 | ||
946 | /** | |
947 | * Returns a count of the current number of repetitions of Equipment Instance Identifier (OBX-18). | |
948 | * This method does not create a repetition, so if no repetitions have currently been defined or accessed, | |
949 | * it will return zero. | |
950 | */ | |
951 | public int getObx18_EquipmentInstanceIdentifierReps() { | |
952 | 0 | return this.getReps(18); |
953 | } | |
954 | ||
955 | ||
956 | /** | |
957 | * Inserts a repetition of | |
958 | * OBX-18: "Equipment Instance Identifier" at a specific index | |
959 | * | |
960 | * @param rep The repetition index (0-indexed) | |
961 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
962 | */ | |
963 | public EI insertEquipmentInstanceIdentifier(int rep) throws HL7Exception { | |
964 | 0 | return (EI) super.insertRepetition(18, rep); |
965 | } | |
966 | ||
967 | ||
968 | /** | |
969 | * Inserts a repetition of | |
970 | * OBX-18: "Equipment Instance Identifier" at a specific index | |
971 | * | |
972 | * @param rep The repetition index (0-indexed) | |
973 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
974 | */ | |
975 | public EI insertObx18_EquipmentInstanceIdentifier(int rep) throws HL7Exception { | |
976 | 0 | return (EI) super.insertRepetition(18, rep); |
977 | } | |
978 | ||
979 | ||
980 | /** | |
981 | * Removes a repetition of | |
982 | * OBX-18: "Equipment Instance Identifier" at a specific index | |
983 | * | |
984 | * @param rep The repetition index (0-indexed) | |
985 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
986 | */ | |
987 | public EI removeEquipmentInstanceIdentifier(int rep) throws HL7Exception { | |
988 | 0 | return (EI) super.removeRepetition(18, rep); |
989 | } | |
990 | ||
991 | ||
992 | /** | |
993 | * Removes a repetition of | |
994 | * OBX-18: "Equipment Instance Identifier" at a specific index | |
995 | * | |
996 | * @param rep The repetition index (0-indexed) | |
997 | * @throws HL7Exception If the rep is invalid (below 0, or too high for the allowable repetitions) | |
998 | */ | |
999 | public EI removeObx18_EquipmentInstanceIdentifier(int rep) throws HL7Exception { | |
1000 | 0 | return (EI) super.removeRepetition(18, rep); |
1001 | } | |
1002 | ||
1003 | ||
1004 | ||
1005 | ||
1006 | /** | |
1007 | * Returns | |
1008 | * OBX-19: "Date/Time of the Analysis" - creates it if necessary | |
1009 | */ | |
1010 | public TS getDateTimeOfTheAnalysis() { | |
1011 | 0 | TS retVal = this.getTypedField(19, 0); |
1012 | 0 | return retVal; |
1013 | } | |
1014 | ||
1015 | /** | |
1016 | * Returns | |
1017 | * OBX-19: "Date/Time of the Analysis" - creates it if necessary | |
1018 | */ | |
1019 | public TS getObx19_DateTimeOfTheAnalysis() { | |
1020 | 0 | TS retVal = this.getTypedField(19, 0); |
1021 | 0 | return retVal; |
1022 | } | |
1023 | ||
1024 | ||
1025 | ||
1026 | ||
1027 | ||
1028 | /** {@inheritDoc} */ | |
1029 | protected Type createNewTypeWithoutReflection(int field) { | |
1030 | 10 | switch (field) { |
1031 | 10 | case 0: return new SI(getMessage()); |
1032 | 0 | case 1: return new ID(getMessage(), new Integer( 125 )); |
1033 | 0 | case 2: return new CE(getMessage()); |
1034 | 0 | case 3: return new ST(getMessage()); |
1035 | 0 | case 4: return new Varies(getMessage()); |
1036 | 0 | case 5: return new CE(getMessage()); |
1037 | 0 | case 6: return new ST(getMessage()); |
1038 | 0 | case 7: return new IS(getMessage(), new Integer( 78 )); |
1039 | 0 | case 8: return new NM(getMessage()); |
1040 | 0 | case 9: return new ID(getMessage(), new Integer( 80 )); |
1041 | 0 | case 10: return new ID(getMessage(), new Integer( 85 )); |
1042 | 0 | case 11: return new TS(getMessage()); |
1043 | 0 | case 12: return new ST(getMessage()); |
1044 | 0 | case 13: return new TS(getMessage()); |
1045 | 0 | case 14: return new CE(getMessage()); |
1046 | 0 | case 15: return new XCN(getMessage()); |
1047 | 0 | case 16: return new CE(getMessage()); |
1048 | 0 | case 17: return new EI(getMessage()); |
1049 | 0 | case 18: return new TS(getMessage()); |
1050 | 0 | default: return null; |
1051 | } | |
1052 | } | |
1053 | ||
1054 | ||
1055 | } | |
1056 |