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 &copy)
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 &copy)
72 {
73     if (this != &copy)
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 &copy)
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 &copy)
661 {
662     if (this != &copy)
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