1 /*
2 *
3 * Copyright (C) 2008-2012, OFFIS e.V. and ICSMED AG, Oldenburg, Germany
4 * Copyright (C) 2013-2017, J. Riesmeier, Oldenburg, Germany
5 * All rights reserved. See COPYRIGHT file for details.
6 *
7 * Source file for class DRTIonToleranceTableSequence
8 *
9 * Generated automatically from DICOM PS 3.3-2017e
10 * File created on 2017-12-05 09:30:54
11 *
12 */
13
14
15 #include "dcmtk/config/osconfig.h" // make sure OS specific configuration is included first
16
17 #include "dcmtk/dcmrt/seq/drtitts.h"
18
19
20 // --- item class ---
21
Item(const OFBool emptyDefaultItem)22 DRTIonToleranceTableSequence::Item::Item(const OFBool emptyDefaultItem)
23 : EmptyDefaultItem(emptyDefaultItem),
24 BeamLimitingDeviceAngleTolerance(DCM_BeamLimitingDeviceAngleTolerance),
25 BeamLimitingDeviceToleranceSequence(emptyDefaultItem /*emptyDefaultSequence*/),
26 ChairHeadFramePositionTolerance(DCM_ChairHeadFramePositionTolerance),
27 FixationLightAzimuthalAngleTolerance(DCM_FixationLightAzimuthalAngleTolerance),
28 FixationLightPolarAngleTolerance(DCM_FixationLightPolarAngleTolerance),
29 GantryAngleTolerance(DCM_GantryAngleTolerance),
30 HeadFixationAngleTolerance(DCM_HeadFixationAngleTolerance),
31 PatientSupportAngleTolerance(DCM_PatientSupportAngleTolerance),
32 SnoutPositionTolerance(DCM_SnoutPositionTolerance),
33 TableTopLateralPositionTolerance(DCM_TableTopLateralPositionTolerance),
34 TableTopLongitudinalPositionTolerance(DCM_TableTopLongitudinalPositionTolerance),
35 TableTopPitchAngleTolerance(DCM_TableTopPitchAngleTolerance),
36 TableTopRollAngleTolerance(DCM_TableTopRollAngleTolerance),
37 TableTopVerticalPositionTolerance(DCM_TableTopVerticalPositionTolerance),
38 ToleranceTableLabel(DCM_ToleranceTableLabel),
39 ToleranceTableNumber(DCM_ToleranceTableNumber)
40 {
41 }
42
43
Item(const Item & copy)44 DRTIonToleranceTableSequence::Item::Item(const Item ©)
45 : EmptyDefaultItem(copy.EmptyDefaultItem),
46 BeamLimitingDeviceAngleTolerance(copy.BeamLimitingDeviceAngleTolerance),
47 BeamLimitingDeviceToleranceSequence(copy.BeamLimitingDeviceToleranceSequence),
48 ChairHeadFramePositionTolerance(copy.ChairHeadFramePositionTolerance),
49 FixationLightAzimuthalAngleTolerance(copy.FixationLightAzimuthalAngleTolerance),
50 FixationLightPolarAngleTolerance(copy.FixationLightPolarAngleTolerance),
51 GantryAngleTolerance(copy.GantryAngleTolerance),
52 HeadFixationAngleTolerance(copy.HeadFixationAngleTolerance),
53 PatientSupportAngleTolerance(copy.PatientSupportAngleTolerance),
54 SnoutPositionTolerance(copy.SnoutPositionTolerance),
55 TableTopLateralPositionTolerance(copy.TableTopLateralPositionTolerance),
56 TableTopLongitudinalPositionTolerance(copy.TableTopLongitudinalPositionTolerance),
57 TableTopPitchAngleTolerance(copy.TableTopPitchAngleTolerance),
58 TableTopRollAngleTolerance(copy.TableTopRollAngleTolerance),
59 TableTopVerticalPositionTolerance(copy.TableTopVerticalPositionTolerance),
60 ToleranceTableLabel(copy.ToleranceTableLabel),
61 ToleranceTableNumber(copy.ToleranceTableNumber)
62 {
63 }
64
65
~Item()66 DRTIonToleranceTableSequence::Item::~Item()
67 {
68 }
69
70
operator =(const Item & copy)71 DRTIonToleranceTableSequence::Item &DRTIonToleranceTableSequence::Item::operator=(const Item ©)
72 {
73 if (this != ©)
74 {
75 EmptyDefaultItem = copy.EmptyDefaultItem;
76 BeamLimitingDeviceAngleTolerance = copy.BeamLimitingDeviceAngleTolerance;
77 BeamLimitingDeviceToleranceSequence = copy.BeamLimitingDeviceToleranceSequence;
78 ChairHeadFramePositionTolerance = copy.ChairHeadFramePositionTolerance;
79 FixationLightAzimuthalAngleTolerance = copy.FixationLightAzimuthalAngleTolerance;
80 FixationLightPolarAngleTolerance = copy.FixationLightPolarAngleTolerance;
81 GantryAngleTolerance = copy.GantryAngleTolerance;
82 HeadFixationAngleTolerance = copy.HeadFixationAngleTolerance;
83 PatientSupportAngleTolerance = copy.PatientSupportAngleTolerance;
84 SnoutPositionTolerance = copy.SnoutPositionTolerance;
85 TableTopLateralPositionTolerance = copy.TableTopLateralPositionTolerance;
86 TableTopLongitudinalPositionTolerance = copy.TableTopLongitudinalPositionTolerance;
87 TableTopPitchAngleTolerance = copy.TableTopPitchAngleTolerance;
88 TableTopRollAngleTolerance = copy.TableTopRollAngleTolerance;
89 TableTopVerticalPositionTolerance = copy.TableTopVerticalPositionTolerance;
90 ToleranceTableLabel = copy.ToleranceTableLabel;
91 ToleranceTableNumber = copy.ToleranceTableNumber;
92 }
93 return *this;
94 }
95
96
clear()97 void DRTIonToleranceTableSequence::Item::clear()
98 {
99 if (!EmptyDefaultItem)
100 {
101 /* clear all DICOM attributes */
102 ToleranceTableNumber.clear();
103 ToleranceTableLabel.clear();
104 GantryAngleTolerance.clear();
105 BeamLimitingDeviceAngleTolerance.clear();
106 BeamLimitingDeviceToleranceSequence.clear();
107 PatientSupportAngleTolerance.clear();
108 TableTopVerticalPositionTolerance.clear();
109 TableTopLongitudinalPositionTolerance.clear();
110 TableTopLateralPositionTolerance.clear();
111 TableTopPitchAngleTolerance.clear();
112 TableTopRollAngleTolerance.clear();
113 SnoutPositionTolerance.clear();
114 HeadFixationAngleTolerance.clear();
115 ChairHeadFramePositionTolerance.clear();
116 FixationLightAzimuthalAngleTolerance.clear();
117 FixationLightPolarAngleTolerance.clear();
118 }
119 }
120
121
isEmpty()122 OFBool DRTIonToleranceTableSequence::Item::isEmpty()
123 {
124 return ToleranceTableNumber.isEmpty() &&
125 ToleranceTableLabel.isEmpty() &&
126 GantryAngleTolerance.isEmpty() &&
127 BeamLimitingDeviceAngleTolerance.isEmpty() &&
128 BeamLimitingDeviceToleranceSequence.isEmpty() &&
129 PatientSupportAngleTolerance.isEmpty() &&
130 TableTopVerticalPositionTolerance.isEmpty() &&
131 TableTopLongitudinalPositionTolerance.isEmpty() &&
132 TableTopLateralPositionTolerance.isEmpty() &&
133 TableTopPitchAngleTolerance.isEmpty() &&
134 TableTopRollAngleTolerance.isEmpty() &&
135 SnoutPositionTolerance.isEmpty() &&
136 HeadFixationAngleTolerance.isEmpty() &&
137 ChairHeadFramePositionTolerance.isEmpty() &&
138 FixationLightAzimuthalAngleTolerance.isEmpty() &&
139 FixationLightPolarAngleTolerance.isEmpty();
140 }
141
142
isValid() const143 OFBool DRTIonToleranceTableSequence::Item::isValid() const
144 {
145 return !EmptyDefaultItem;
146 }
147
148
read(DcmItem & item)149 OFCondition DRTIonToleranceTableSequence::Item::read(DcmItem &item)
150 {
151 OFCondition result = EC_IllegalCall;
152 if (!EmptyDefaultItem)
153 {
154 /* re-initialize object */
155 clear();
156 getAndCheckElementFromDataset(item, ToleranceTableNumber, "1", "1", "IonToleranceTableSequence");
157 getAndCheckElementFromDataset(item, ToleranceTableLabel, "1", "3", "IonToleranceTableSequence");
158 getAndCheckElementFromDataset(item, GantryAngleTolerance, "1", "3", "IonToleranceTableSequence");
159 getAndCheckElementFromDataset(item, BeamLimitingDeviceAngleTolerance, "1", "3", "IonToleranceTableSequence");
160 BeamLimitingDeviceToleranceSequence.read(item, "1-n", "3", "IonToleranceTableSequence");
161 getAndCheckElementFromDataset(item, PatientSupportAngleTolerance, "1", "3", "IonToleranceTableSequence");
162 getAndCheckElementFromDataset(item, TableTopVerticalPositionTolerance, "1", "3", "IonToleranceTableSequence");
163 getAndCheckElementFromDataset(item, TableTopLongitudinalPositionTolerance, "1", "3", "IonToleranceTableSequence");
164 getAndCheckElementFromDataset(item, TableTopLateralPositionTolerance, "1", "3", "IonToleranceTableSequence");
165 getAndCheckElementFromDataset(item, TableTopPitchAngleTolerance, "1", "3", "IonToleranceTableSequence");
166 getAndCheckElementFromDataset(item, TableTopRollAngleTolerance, "1", "3", "IonToleranceTableSequence");
167 getAndCheckElementFromDataset(item, SnoutPositionTolerance, "1", "3", "IonToleranceTableSequence");
168 getAndCheckElementFromDataset(item, HeadFixationAngleTolerance, "1", "3", "IonToleranceTableSequence");
169 getAndCheckElementFromDataset(item, ChairHeadFramePositionTolerance, "1", "3", "IonToleranceTableSequence");
170 getAndCheckElementFromDataset(item, FixationLightAzimuthalAngleTolerance, "1", "3", "IonToleranceTableSequence");
171 getAndCheckElementFromDataset(item, FixationLightPolarAngleTolerance, "1", "3", "IonToleranceTableSequence");
172 result = EC_Normal;
173 }
174 return result;
175 }
176
177
write(DcmItem & item)178 OFCondition DRTIonToleranceTableSequence::Item::write(DcmItem &item)
179 {
180 OFCondition result = EC_IllegalCall;
181 if (!EmptyDefaultItem)
182 {
183 result = EC_Normal;
184 addElementToDataset(result, item, new DcmIntegerString(ToleranceTableNumber), "1", "1", "IonToleranceTableSequence");
185 addElementToDataset(result, item, new DcmShortString(ToleranceTableLabel), "1", "3", "IonToleranceTableSequence");
186 addElementToDataset(result, item, new DcmDecimalString(GantryAngleTolerance), "1", "3", "IonToleranceTableSequence");
187 addElementToDataset(result, item, new DcmDecimalString(BeamLimitingDeviceAngleTolerance), "1", "3", "IonToleranceTableSequence");
188 if (result.good()) result = BeamLimitingDeviceToleranceSequence.write(item, "1-n", "3", "IonToleranceTableSequence");
189 addElementToDataset(result, item, new DcmDecimalString(PatientSupportAngleTolerance), "1", "3", "IonToleranceTableSequence");
190 addElementToDataset(result, item, new DcmDecimalString(TableTopVerticalPositionTolerance), "1", "3", "IonToleranceTableSequence");
191 addElementToDataset(result, item, new DcmDecimalString(TableTopLongitudinalPositionTolerance), "1", "3", "IonToleranceTableSequence");
192 addElementToDataset(result, item, new DcmDecimalString(TableTopLateralPositionTolerance), "1", "3", "IonToleranceTableSequence");
193 addElementToDataset(result, item, new DcmFloatingPointSingle(TableTopPitchAngleTolerance), "1", "3", "IonToleranceTableSequence");
194 addElementToDataset(result, item, new DcmFloatingPointSingle(TableTopRollAngleTolerance), "1", "3", "IonToleranceTableSequence");
195 addElementToDataset(result, item, new DcmFloatingPointSingle(SnoutPositionTolerance), "1", "3", "IonToleranceTableSequence");
196 addElementToDataset(result, item, new DcmDecimalString(HeadFixationAngleTolerance), "1", "3", "IonToleranceTableSequence");
197 addElementToDataset(result, item, new DcmDecimalString(ChairHeadFramePositionTolerance), "1", "3", "IonToleranceTableSequence");
198 addElementToDataset(result, item, new DcmDecimalString(FixationLightAzimuthalAngleTolerance), "1", "3", "IonToleranceTableSequence");
199 addElementToDataset(result, item, new DcmDecimalString(FixationLightPolarAngleTolerance), "1", "3", "IonToleranceTableSequence");
200 }
201 return result;
202 }
203
204
getBeamLimitingDeviceAngleTolerance(OFString & value,const signed long pos) const205 OFCondition DRTIonToleranceTableSequence::Item::getBeamLimitingDeviceAngleTolerance(OFString &value, const signed long pos) const
206 {
207 if (EmptyDefaultItem)
208 return EC_IllegalCall;
209 else
210 return getStringValueFromElement(BeamLimitingDeviceAngleTolerance, value, pos);
211 }
212
213
getBeamLimitingDeviceAngleTolerance(Float64 & value,const unsigned long pos) const214 OFCondition DRTIonToleranceTableSequence::Item::getBeamLimitingDeviceAngleTolerance(Float64 &value, const unsigned long pos) const
215 {
216 if (EmptyDefaultItem)
217 return EC_IllegalCall;
218 else
219 return OFconst_cast(DcmDecimalString &, BeamLimitingDeviceAngleTolerance).getFloat64(value, pos);
220 }
221
222
getChairHeadFramePositionTolerance(OFString & value,const signed long pos) const223 OFCondition DRTIonToleranceTableSequence::Item::getChairHeadFramePositionTolerance(OFString &value, const signed long pos) const
224 {
225 if (EmptyDefaultItem)
226 return EC_IllegalCall;
227 else
228 return getStringValueFromElement(ChairHeadFramePositionTolerance, value, pos);
229 }
230
231
getChairHeadFramePositionTolerance(Float64 & value,const unsigned long pos) const232 OFCondition DRTIonToleranceTableSequence::Item::getChairHeadFramePositionTolerance(Float64 &value, const unsigned long pos) const
233 {
234 if (EmptyDefaultItem)
235 return EC_IllegalCall;
236 else
237 return OFconst_cast(DcmDecimalString &, ChairHeadFramePositionTolerance).getFloat64(value, pos);
238 }
239
240
getFixationLightAzimuthalAngleTolerance(OFString & value,const signed long pos) const241 OFCondition DRTIonToleranceTableSequence::Item::getFixationLightAzimuthalAngleTolerance(OFString &value, const signed long pos) const
242 {
243 if (EmptyDefaultItem)
244 return EC_IllegalCall;
245 else
246 return getStringValueFromElement(FixationLightAzimuthalAngleTolerance, value, pos);
247 }
248
249
getFixationLightAzimuthalAngleTolerance(Float64 & value,const unsigned long pos) const250 OFCondition DRTIonToleranceTableSequence::Item::getFixationLightAzimuthalAngleTolerance(Float64 &value, const unsigned long pos) const
251 {
252 if (EmptyDefaultItem)
253 return EC_IllegalCall;
254 else
255 return OFconst_cast(DcmDecimalString &, FixationLightAzimuthalAngleTolerance).getFloat64(value, pos);
256 }
257
258
getFixationLightPolarAngleTolerance(OFString & value,const signed long pos) const259 OFCondition DRTIonToleranceTableSequence::Item::getFixationLightPolarAngleTolerance(OFString &value, const signed long pos) const
260 {
261 if (EmptyDefaultItem)
262 return EC_IllegalCall;
263 else
264 return getStringValueFromElement(FixationLightPolarAngleTolerance, value, pos);
265 }
266
267
getFixationLightPolarAngleTolerance(Float64 & value,const unsigned long pos) const268 OFCondition DRTIonToleranceTableSequence::Item::getFixationLightPolarAngleTolerance(Float64 &value, const unsigned long pos) const
269 {
270 if (EmptyDefaultItem)
271 return EC_IllegalCall;
272 else
273 return OFconst_cast(DcmDecimalString &, FixationLightPolarAngleTolerance).getFloat64(value, pos);
274 }
275
276
getGantryAngleTolerance(OFString & value,const signed long pos) const277 OFCondition DRTIonToleranceTableSequence::Item::getGantryAngleTolerance(OFString &value, const signed long pos) const
278 {
279 if (EmptyDefaultItem)
280 return EC_IllegalCall;
281 else
282 return getStringValueFromElement(GantryAngleTolerance, value, pos);
283 }
284
285
getGantryAngleTolerance(Float64 & value,const unsigned long pos) const286 OFCondition DRTIonToleranceTableSequence::Item::getGantryAngleTolerance(Float64 &value, const unsigned long pos) const
287 {
288 if (EmptyDefaultItem)
289 return EC_IllegalCall;
290 else
291 return OFconst_cast(DcmDecimalString &, GantryAngleTolerance).getFloat64(value, pos);
292 }
293
294
getHeadFixationAngleTolerance(OFString & value,const signed long pos) const295 OFCondition DRTIonToleranceTableSequence::Item::getHeadFixationAngleTolerance(OFString &value, const signed long pos) const
296 {
297 if (EmptyDefaultItem)
298 return EC_IllegalCall;
299 else
300 return getStringValueFromElement(HeadFixationAngleTolerance, value, pos);
301 }
302
303
getHeadFixationAngleTolerance(Float64 & value,const unsigned long pos) const304 OFCondition DRTIonToleranceTableSequence::Item::getHeadFixationAngleTolerance(Float64 &value, const unsigned long pos) const
305 {
306 if (EmptyDefaultItem)
307 return EC_IllegalCall;
308 else
309 return OFconst_cast(DcmDecimalString &, HeadFixationAngleTolerance).getFloat64(value, pos);
310 }
311
312
getPatientSupportAngleTolerance(OFString & value,const signed long pos) const313 OFCondition DRTIonToleranceTableSequence::Item::getPatientSupportAngleTolerance(OFString &value, const signed long pos) const
314 {
315 if (EmptyDefaultItem)
316 return EC_IllegalCall;
317 else
318 return getStringValueFromElement(PatientSupportAngleTolerance, value, pos);
319 }
320
321
getPatientSupportAngleTolerance(Float64 & value,const unsigned long pos) const322 OFCondition DRTIonToleranceTableSequence::Item::getPatientSupportAngleTolerance(Float64 &value, const unsigned long pos) const
323 {
324 if (EmptyDefaultItem)
325 return EC_IllegalCall;
326 else
327 return OFconst_cast(DcmDecimalString &, PatientSupportAngleTolerance).getFloat64(value, pos);
328 }
329
330
getSnoutPositionTolerance(Float32 & value,const unsigned long pos) const331 OFCondition DRTIonToleranceTableSequence::Item::getSnoutPositionTolerance(Float32 &value, const unsigned long pos) const
332 {
333 if (EmptyDefaultItem)
334 return EC_IllegalCall;
335 else
336 return OFconst_cast(DcmFloatingPointSingle &, SnoutPositionTolerance).getFloat32(value, pos);
337 }
338
339
getTableTopLateralPositionTolerance(OFString & value,const signed long pos) const340 OFCondition DRTIonToleranceTableSequence::Item::getTableTopLateralPositionTolerance(OFString &value, const signed long pos) const
341 {
342 if (EmptyDefaultItem)
343 return EC_IllegalCall;
344 else
345 return getStringValueFromElement(TableTopLateralPositionTolerance, value, pos);
346 }
347
348
getTableTopLateralPositionTolerance(Float64 & value,const unsigned long pos) const349 OFCondition DRTIonToleranceTableSequence::Item::getTableTopLateralPositionTolerance(Float64 &value, const unsigned long pos) const
350 {
351 if (EmptyDefaultItem)
352 return EC_IllegalCall;
353 else
354 return OFconst_cast(DcmDecimalString &, TableTopLateralPositionTolerance).getFloat64(value, pos);
355 }
356
357
getTableTopLongitudinalPositionTolerance(OFString & value,const signed long pos) const358 OFCondition DRTIonToleranceTableSequence::Item::getTableTopLongitudinalPositionTolerance(OFString &value, const signed long pos) const
359 {
360 if (EmptyDefaultItem)
361 return EC_IllegalCall;
362 else
363 return getStringValueFromElement(TableTopLongitudinalPositionTolerance, value, pos);
364 }
365
366
getTableTopLongitudinalPositionTolerance(Float64 & value,const unsigned long pos) const367 OFCondition DRTIonToleranceTableSequence::Item::getTableTopLongitudinalPositionTolerance(Float64 &value, const unsigned long pos) const
368 {
369 if (EmptyDefaultItem)
370 return EC_IllegalCall;
371 else
372 return OFconst_cast(DcmDecimalString &, TableTopLongitudinalPositionTolerance).getFloat64(value, pos);
373 }
374
375
getTableTopPitchAngleTolerance(Float32 & value,const unsigned long pos) const376 OFCondition DRTIonToleranceTableSequence::Item::getTableTopPitchAngleTolerance(Float32 &value, const unsigned long pos) const
377 {
378 if (EmptyDefaultItem)
379 return EC_IllegalCall;
380 else
381 return OFconst_cast(DcmFloatingPointSingle &, TableTopPitchAngleTolerance).getFloat32(value, pos);
382 }
383
384
getTableTopRollAngleTolerance(Float32 & value,const unsigned long pos) const385 OFCondition DRTIonToleranceTableSequence::Item::getTableTopRollAngleTolerance(Float32 &value, const unsigned long pos) const
386 {
387 if (EmptyDefaultItem)
388 return EC_IllegalCall;
389 else
390 return OFconst_cast(DcmFloatingPointSingle &, TableTopRollAngleTolerance).getFloat32(value, pos);
391 }
392
393
getTableTopVerticalPositionTolerance(OFString & value,const signed long pos) const394 OFCondition DRTIonToleranceTableSequence::Item::getTableTopVerticalPositionTolerance(OFString &value, const signed long pos) const
395 {
396 if (EmptyDefaultItem)
397 return EC_IllegalCall;
398 else
399 return getStringValueFromElement(TableTopVerticalPositionTolerance, value, pos);
400 }
401
402
getTableTopVerticalPositionTolerance(Float64 & value,const unsigned long pos) const403 OFCondition DRTIonToleranceTableSequence::Item::getTableTopVerticalPositionTolerance(Float64 &value, const unsigned long pos) const
404 {
405 if (EmptyDefaultItem)
406 return EC_IllegalCall;
407 else
408 return OFconst_cast(DcmDecimalString &, TableTopVerticalPositionTolerance).getFloat64(value, pos);
409 }
410
411
getToleranceTableLabel(OFString & value,const signed long pos) const412 OFCondition DRTIonToleranceTableSequence::Item::getToleranceTableLabel(OFString &value, const signed long pos) const
413 {
414 if (EmptyDefaultItem)
415 return EC_IllegalCall;
416 else
417 return getStringValueFromElement(ToleranceTableLabel, value, pos);
418 }
419
420
getToleranceTableNumber(OFString & value,const signed long pos) const421 OFCondition DRTIonToleranceTableSequence::Item::getToleranceTableNumber(OFString &value, const signed long pos) const
422 {
423 if (EmptyDefaultItem)
424 return EC_IllegalCall;
425 else
426 return getStringValueFromElement(ToleranceTableNumber, value, pos);
427 }
428
429
getToleranceTableNumber(Sint32 & value,const unsigned long pos) const430 OFCondition DRTIonToleranceTableSequence::Item::getToleranceTableNumber(Sint32 &value, const unsigned long pos) const
431 {
432 if (EmptyDefaultItem)
433 return EC_IllegalCall;
434 else
435 return OFconst_cast(DcmIntegerString &, ToleranceTableNumber).getSint32(value, pos);
436 }
437
438
setBeamLimitingDeviceAngleTolerance(const OFString & value,const OFBool check)439 OFCondition DRTIonToleranceTableSequence::Item::setBeamLimitingDeviceAngleTolerance(const OFString &value, const OFBool check)
440 {
441 OFCondition result = EC_IllegalCall;
442 if (!EmptyDefaultItem)
443 {
444 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
445 if (result.good())
446 result = BeamLimitingDeviceAngleTolerance.putOFStringArray(value);
447 }
448 return result;
449 }
450
451
setChairHeadFramePositionTolerance(const OFString & value,const OFBool check)452 OFCondition DRTIonToleranceTableSequence::Item::setChairHeadFramePositionTolerance(const OFString &value, const OFBool check)
453 {
454 OFCondition result = EC_IllegalCall;
455 if (!EmptyDefaultItem)
456 {
457 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
458 if (result.good())
459 result = ChairHeadFramePositionTolerance.putOFStringArray(value);
460 }
461 return result;
462 }
463
464
setFixationLightAzimuthalAngleTolerance(const OFString & value,const OFBool check)465 OFCondition DRTIonToleranceTableSequence::Item::setFixationLightAzimuthalAngleTolerance(const OFString &value, const OFBool check)
466 {
467 OFCondition result = EC_IllegalCall;
468 if (!EmptyDefaultItem)
469 {
470 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
471 if (result.good())
472 result = FixationLightAzimuthalAngleTolerance.putOFStringArray(value);
473 }
474 return result;
475 }
476
477
setFixationLightPolarAngleTolerance(const OFString & value,const OFBool check)478 OFCondition DRTIonToleranceTableSequence::Item::setFixationLightPolarAngleTolerance(const OFString &value, const OFBool check)
479 {
480 OFCondition result = EC_IllegalCall;
481 if (!EmptyDefaultItem)
482 {
483 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
484 if (result.good())
485 result = FixationLightPolarAngleTolerance.putOFStringArray(value);
486 }
487 return result;
488 }
489
490
setGantryAngleTolerance(const OFString & value,const OFBool check)491 OFCondition DRTIonToleranceTableSequence::Item::setGantryAngleTolerance(const OFString &value, const OFBool check)
492 {
493 OFCondition result = EC_IllegalCall;
494 if (!EmptyDefaultItem)
495 {
496 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
497 if (result.good())
498 result = GantryAngleTolerance.putOFStringArray(value);
499 }
500 return result;
501 }
502
503
setHeadFixationAngleTolerance(const OFString & value,const OFBool check)504 OFCondition DRTIonToleranceTableSequence::Item::setHeadFixationAngleTolerance(const OFString &value, const OFBool check)
505 {
506 OFCondition result = EC_IllegalCall;
507 if (!EmptyDefaultItem)
508 {
509 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
510 if (result.good())
511 result = HeadFixationAngleTolerance.putOFStringArray(value);
512 }
513 return result;
514 }
515
516
setPatientSupportAngleTolerance(const OFString & value,const OFBool check)517 OFCondition DRTIonToleranceTableSequence::Item::setPatientSupportAngleTolerance(const OFString &value, const OFBool check)
518 {
519 OFCondition result = EC_IllegalCall;
520 if (!EmptyDefaultItem)
521 {
522 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
523 if (result.good())
524 result = PatientSupportAngleTolerance.putOFStringArray(value);
525 }
526 return result;
527 }
528
529
setSnoutPositionTolerance(const Float32 value,const unsigned long pos)530 OFCondition DRTIonToleranceTableSequence::Item::setSnoutPositionTolerance(const Float32 value, const unsigned long pos)
531 {
532 if (EmptyDefaultItem)
533 return EC_IllegalCall;
534 else
535 return SnoutPositionTolerance.putFloat32(value, pos);
536 }
537
538
setTableTopLateralPositionTolerance(const OFString & value,const OFBool check)539 OFCondition DRTIonToleranceTableSequence::Item::setTableTopLateralPositionTolerance(const OFString &value, const OFBool check)
540 {
541 OFCondition result = EC_IllegalCall;
542 if (!EmptyDefaultItem)
543 {
544 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
545 if (result.good())
546 result = TableTopLateralPositionTolerance.putOFStringArray(value);
547 }
548 return result;
549 }
550
551
setTableTopLongitudinalPositionTolerance(const OFString & value,const OFBool check)552 OFCondition DRTIonToleranceTableSequence::Item::setTableTopLongitudinalPositionTolerance(const OFString &value, const OFBool check)
553 {
554 OFCondition result = EC_IllegalCall;
555 if (!EmptyDefaultItem)
556 {
557 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
558 if (result.good())
559 result = TableTopLongitudinalPositionTolerance.putOFStringArray(value);
560 }
561 return result;
562 }
563
564
setTableTopPitchAngleTolerance(const Float32 value,const unsigned long pos)565 OFCondition DRTIonToleranceTableSequence::Item::setTableTopPitchAngleTolerance(const Float32 value, const unsigned long pos)
566 {
567 if (EmptyDefaultItem)
568 return EC_IllegalCall;
569 else
570 return TableTopPitchAngleTolerance.putFloat32(value, pos);
571 }
572
573
setTableTopRollAngleTolerance(const Float32 value,const unsigned long pos)574 OFCondition DRTIonToleranceTableSequence::Item::setTableTopRollAngleTolerance(const Float32 value, const unsigned long pos)
575 {
576 if (EmptyDefaultItem)
577 return EC_IllegalCall;
578 else
579 return TableTopRollAngleTolerance.putFloat32(value, pos);
580 }
581
582
setTableTopVerticalPositionTolerance(const OFString & value,const OFBool check)583 OFCondition DRTIonToleranceTableSequence::Item::setTableTopVerticalPositionTolerance(const OFString &value, const OFBool check)
584 {
585 OFCondition result = EC_IllegalCall;
586 if (!EmptyDefaultItem)
587 {
588 result = (check) ? DcmDecimalString::checkStringValue(value, "1") : EC_Normal;
589 if (result.good())
590 result = TableTopVerticalPositionTolerance.putOFStringArray(value);
591 }
592 return result;
593 }
594
595
setToleranceTableLabel(const OFString & value,const OFBool check)596 OFCondition DRTIonToleranceTableSequence::Item::setToleranceTableLabel(const OFString &value, const OFBool check)
597 {
598 OFCondition result = EC_IllegalCall;
599 if (!EmptyDefaultItem)
600 {
601 result = (check) ? DcmShortString::checkStringValue(value, "1") : EC_Normal;
602 if (result.good())
603 result = ToleranceTableLabel.putOFStringArray(value);
604 }
605 return result;
606 }
607
608
setToleranceTableNumber(const OFString & value,const OFBool check)609 OFCondition DRTIonToleranceTableSequence::Item::setToleranceTableNumber(const OFString &value, const OFBool check)
610 {
611 OFCondition result = EC_IllegalCall;
612 if (!EmptyDefaultItem)
613 {
614 result = (check) ? DcmIntegerString::checkStringValue(value, "1") : EC_Normal;
615 if (result.good())
616 result = ToleranceTableNumber.putOFStringArray(value);
617 }
618 return result;
619 }
620
621
622 // --- sequence class ---
623
DRTIonToleranceTableSequence(const OFBool emptyDefaultSequence)624 DRTIonToleranceTableSequence::DRTIonToleranceTableSequence(const OFBool emptyDefaultSequence)
625 : EmptyDefaultSequence(emptyDefaultSequence),
626 SequenceOfItems(),
627 CurrentItem(),
628 EmptyItem(OFTrue /*emptyDefaultItem*/)
629 {
630 CurrentItem = SequenceOfItems.end();
631 }
632
633
DRTIonToleranceTableSequence(const DRTIonToleranceTableSequence & copy)634 DRTIonToleranceTableSequence::DRTIonToleranceTableSequence(const DRTIonToleranceTableSequence ©)
635 : EmptyDefaultSequence(copy.EmptyDefaultSequence),
636 SequenceOfItems(),
637 CurrentItem(),
638 EmptyItem(OFTrue /*emptyDefaultItem*/)
639 {
640 /* create a copy of the internal sequence of items */
641 Item *item = NULL;
642 OFListConstIterator(Item *) current = copy.SequenceOfItems.begin();
643 const OFListConstIterator(Item *) last = copy.SequenceOfItems.end();
644 while (current != last)
645 {
646 item = new Item(**current);
647 if (item != NULL)
648 {
649 SequenceOfItems.push_back(item);
650 } else {
651 /* memory exhausted, there is nothing we can do about it */
652 break;
653 }
654 ++current;
655 }
656 CurrentItem = SequenceOfItems.begin();
657 }
658
659
operator =(const DRTIonToleranceTableSequence & copy)660 DRTIonToleranceTableSequence &DRTIonToleranceTableSequence::operator=(const DRTIonToleranceTableSequence ©)
661 {
662 if (this != ©)
663 {
664 clear();
665 EmptyDefaultSequence = copy.EmptyDefaultSequence;
666 /* create a copy of the internal sequence of items */
667 Item *item = NULL;
668 OFListConstIterator(Item *) current = copy.SequenceOfItems.begin();
669 const OFListConstIterator(Item *) last = copy.SequenceOfItems.end();
670 while (current != last)
671 {
672 item = new Item(**current);
673 if (item != NULL)
674 {
675 SequenceOfItems.push_back(item);
676 } else {
677 /* memory exhausted, there is nothing we can do about it */
678 break;
679 }
680 ++current;
681 }
682 CurrentItem = SequenceOfItems.begin();
683 }
684 return *this;
685 }
686
687
~DRTIonToleranceTableSequence()688 DRTIonToleranceTableSequence::~DRTIonToleranceTableSequence()
689 {
690 clear();
691 }
692
693
clear()694 void DRTIonToleranceTableSequence::clear()
695 {
696 if (!EmptyDefaultSequence)
697 {
698 CurrentItem = SequenceOfItems.begin();
699 const OFListConstIterator(Item *) last = SequenceOfItems.end();
700 /* delete all items and free memory */
701 while (CurrentItem != last)
702 {
703 delete (*CurrentItem);
704 CurrentItem = SequenceOfItems.erase(CurrentItem);
705 }
706 /* make sure that the list is empty */
707 SequenceOfItems.clear();
708 CurrentItem = SequenceOfItems.end();
709 }
710 }
711
712
isEmpty()713 OFBool DRTIonToleranceTableSequence::isEmpty()
714 {
715 return SequenceOfItems.empty();
716 }
717
718
isValid() const719 OFBool DRTIonToleranceTableSequence::isValid() const
720 {
721 return !EmptyDefaultSequence;
722 }
723
724
getNumberOfItems() const725 size_t DRTIonToleranceTableSequence::getNumberOfItems() const
726 {
727 return SequenceOfItems.size();
728 }
729
730
gotoFirstItem()731 OFCondition DRTIonToleranceTableSequence::gotoFirstItem()
732 {
733 OFCondition result = EC_IllegalCall;
734 if (!SequenceOfItems.empty())
735 {
736 CurrentItem = SequenceOfItems.begin();
737 result = EC_Normal;
738 }
739 return result;
740 }
741
742
gotoNextItem()743 OFCondition DRTIonToleranceTableSequence::gotoNextItem()
744 {
745 OFCondition result = EC_IllegalCall;
746 if (CurrentItem != SequenceOfItems.end())
747 {
748 ++CurrentItem;
749 result = EC_Normal;
750 }
751 return result;
752 }
753
754
gotoItem(const size_t num,OFListIterator (Item *)& iterator)755 OFCondition DRTIonToleranceTableSequence::gotoItem(const size_t num, OFListIterator(Item *) &iterator)
756 {
757 OFCondition result = EC_IllegalCall;
758 if (!SequenceOfItems.empty())
759 {
760 size_t idx = num + 1;
761 iterator = SequenceOfItems.begin();
762 const OFListConstIterator(Item *) last = SequenceOfItems.end();
763 while ((--idx > 0) && (iterator != last))
764 ++iterator;
765 /* specified list item found? */
766 if ((idx == 0) && (iterator != last))
767 result = EC_Normal;
768 else
769 result = EC_IllegalParameter;
770 }
771 return result;
772 }
773
774
gotoItem(const size_t num,OFListConstIterator (Item *)& iterator) const775 OFCondition DRTIonToleranceTableSequence::gotoItem(const size_t num, OFListConstIterator(Item *) &iterator) const
776 {
777 OFCondition result = EC_IllegalCall;
778 if (!SequenceOfItems.empty())
779 {
780 size_t idx = num + 1;
781 iterator = SequenceOfItems.begin();
782 const OFListConstIterator(Item *) last = SequenceOfItems.end();
783 while ((--idx > 0) && (iterator != last))
784 ++iterator;
785 /* specified list item found? */
786 if ((idx == 0) && (iterator != last))
787 result = EC_Normal;
788 else
789 result = EC_IllegalParameter;
790 }
791 return result;
792 }
793
794
gotoItem(const size_t num)795 OFCondition DRTIonToleranceTableSequence::gotoItem(const size_t num)
796 {
797 return gotoItem(num, CurrentItem);
798 }
799
800
getCurrentItem(Item * & item) const801 OFCondition DRTIonToleranceTableSequence::getCurrentItem(Item *&item) const
802 {
803 OFCondition result = EC_IllegalCall;
804 if (CurrentItem != SequenceOfItems.end())
805 {
806 item = *CurrentItem;
807 result = EC_Normal;
808 }
809 return result;
810 }
811
812
getCurrentItem()813 DRTIonToleranceTableSequence::Item &DRTIonToleranceTableSequence::getCurrentItem()
814 {
815 if (CurrentItem != SequenceOfItems.end())
816 return **CurrentItem;
817 else
818 return EmptyItem;
819 }
820
821
getCurrentItem() const822 const DRTIonToleranceTableSequence::Item &DRTIonToleranceTableSequence::getCurrentItem() const
823 {
824 if (CurrentItem != SequenceOfItems.end())
825 return **CurrentItem;
826 else
827 return EmptyItem;
828 }
829
830
getItem(const size_t num,Item * & item)831 OFCondition DRTIonToleranceTableSequence::getItem(const size_t num, Item *&item)
832 {
833 OFListIterator(Item *) iterator;
834 OFCondition result = gotoItem(num, iterator);
835 if (result.good())
836 item = *iterator;
837 return result;
838 }
839
840
getItem(const size_t num)841 DRTIonToleranceTableSequence::Item &DRTIonToleranceTableSequence::getItem(const size_t num)
842 {
843 OFListIterator(Item *) iterator;
844 if (gotoItem(num, iterator).good())
845 return **iterator;
846 else
847 return EmptyItem;
848 }
849
850
getItem(const size_t num) const851 const DRTIonToleranceTableSequence::Item &DRTIonToleranceTableSequence::getItem(const size_t num) const
852 {
853 OFListConstIterator(Item *) iterator;
854 if (gotoItem(num, iterator).good())
855 return **iterator;
856 else
857 return EmptyItem;
858 }
859
860
operator [](const size_t num)861 DRTIonToleranceTableSequence::Item &DRTIonToleranceTableSequence::operator[](const size_t num)
862 {
863 return getItem(num);
864 }
865
866
operator [](const size_t num) const867 const DRTIonToleranceTableSequence::Item &DRTIonToleranceTableSequence::operator[](const size_t num) const
868 {
869 return getItem(num);
870 }
871
872
addItem(Item * & item)873 OFCondition DRTIonToleranceTableSequence::addItem(Item *&item)
874 {
875 OFCondition result = EC_IllegalCall;
876 if (!EmptyDefaultSequence)
877 {
878 item = new Item();
879 if (item != NULL)
880 {
881 SequenceOfItems.push_back(item);
882 result = EC_Normal;
883 } else
884 result = EC_MemoryExhausted;
885 }
886 return result;
887 }
888
889
insertItem(const size_t pos,Item * & item)890 OFCondition DRTIonToleranceTableSequence::insertItem(const size_t pos, Item *&item)
891 {
892 OFCondition result = EC_IllegalCall;
893 if (!EmptyDefaultSequence)
894 {
895 OFListIterator(Item *) iterator;
896 result = gotoItem(pos, iterator);
897 if (result.good())
898 {
899 item = new Item();
900 if (item != NULL)
901 {
902 SequenceOfItems.insert(iterator, 1, item);
903 result = EC_Normal;
904 } else
905 result = EC_MemoryExhausted;
906 } else
907 result = addItem(item);
908 }
909 return result;
910 }
911
912
removeItem(const size_t pos)913 OFCondition DRTIonToleranceTableSequence::removeItem(const size_t pos)
914 {
915 OFCondition result = EC_IllegalCall;
916 if (!EmptyDefaultSequence)
917 {
918 OFListIterator(Item *) iterator;
919 if (gotoItem(pos, iterator).good())
920 {
921 delete *iterator;
922 iterator = SequenceOfItems.erase(iterator);
923 result = EC_Normal;
924 } else
925 result = EC_IllegalParameter;
926 }
927 return result;
928 }
929
930
read(DcmItem & dataset,const OFString & card,const OFString & type,const char * moduleName)931 OFCondition DRTIonToleranceTableSequence::read(DcmItem &dataset,
932 const OFString &card,
933 const OFString &type,
934 const char *moduleName)
935 {
936 OFCondition result = EC_IllegalCall;
937 if (!EmptyDefaultSequence)
938 {
939 /* re-initialize object */
940 clear();
941 /* retrieve sequence element from dataset */
942 DcmSequenceOfItems *sequence;
943 result = dataset.findAndGetSequence(DCM_IonToleranceTableSequence, sequence);
944 if (sequence != NULL)
945 {
946 if (checkElementValue(*sequence, card, type, result, moduleName))
947 {
948 DcmStack stack;
949 OFBool first = OFTrue;
950 /* iterate over all sequence items */
951 while (result.good() && sequence->nextObject(stack, first /*intoSub*/).good())
952 {
953 DcmItem *ditem = OFstatic_cast(DcmItem *, stack.top());
954 if (ditem != NULL)
955 {
956 Item *item = new Item();
957 if (item != NULL)
958 {
959 result = item->read(*ditem);
960 if (result.good())
961 {
962 /* append new item to the end of the list */
963 SequenceOfItems.push_back(item);
964 first = OFFalse;
965 }
966 } else
967 result = EC_MemoryExhausted;
968 } else
969 result = EC_CorruptedData;
970 }
971 }
972 } else {
973 DcmSequenceOfItems element(DCM_IonToleranceTableSequence);
974 checkElementValue(element, card, type, result, moduleName);
975 }
976 }
977 return result;
978 }
979
980
write(DcmItem & dataset,const OFString & card,const OFString & type,const char * moduleName)981 OFCondition DRTIonToleranceTableSequence::write(DcmItem &dataset,
982 const OFString &card,
983 const OFString &type,
984 const char *moduleName)
985 {
986 OFCondition result = EC_IllegalCall;
987 if (!EmptyDefaultSequence)
988 {
989 result = EC_MemoryExhausted;
990 DcmSequenceOfItems *sequence = new DcmSequenceOfItems(DCM_IonToleranceTableSequence);
991 if (sequence != NULL)
992 {
993 result = EC_Normal;
994 /* an empty optional sequence is not written */
995 if ((type == "2") || !SequenceOfItems.empty())
996 {
997 OFListIterator(Item *) iterator = SequenceOfItems.begin();
998 const OFListConstIterator(Item *) last = SequenceOfItems.end();
999 /* iterate over all sequence items */
1000 while (result.good() && (iterator != last))
1001 {
1002 DcmItem *item = new DcmItem();
1003 if (item != NULL)
1004 {
1005 /* append new item to the end of the sequence */
1006 result = sequence->append(item);
1007 if (result.good())
1008 {
1009 result = (*iterator)->write(*item);
1010 ++iterator;
1011 } else
1012 delete item;
1013 } else
1014 result = EC_MemoryExhausted;
1015 }
1016 if (result.good())
1017 {
1018 /* insert sequence element into the dataset */
1019 result = dataset.insert(sequence, OFTrue /*replaceOld*/);
1020 }
1021 if (DCM_dcmrtLogger.isEnabledFor(OFLogger::WARN_LOG_LEVEL))
1022 checkElementValue(*sequence, card, type, result, moduleName);
1023 if (result.good())
1024 {
1025 /* forget reference to sequence object (avoid deletion below) */
1026 sequence = NULL;
1027 }
1028 }
1029 else if (type == "1")
1030 {
1031 /* empty type 1 sequence not allowed */
1032 result = RT_EC_InvalidValue;
1033 if (DCM_dcmrtLogger.isEnabledFor(OFLogger::WARN_LOG_LEVEL))
1034 checkElementValue(*sequence, card, type, result, moduleName);
1035 }
1036 /* delete sequence (if not inserted into the dataset) */
1037 delete sequence;
1038 }
1039 }
1040 return result;
1041 }
1042
1043
1044 // end of source file
1045