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 DRTApplicatorGeometrySequence
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/drtags.h"
18
19
20 // --- item class ---
21
Item(const OFBool emptyDefaultItem)22 DRTApplicatorGeometrySequence::Item::Item(const OFBool emptyDefaultItem)
23 : EmptyDefaultItem(emptyDefaultItem),
24 ApplicatorApertureShape(DCM_ApplicatorApertureShape),
25 ApplicatorOpening(DCM_ApplicatorOpening),
26 ApplicatorOpeningX(DCM_ApplicatorOpeningX),
27 ApplicatorOpeningY(DCM_ApplicatorOpeningY)
28 {
29 }
30
31
Item(const Item & copy)32 DRTApplicatorGeometrySequence::Item::Item(const Item ©)
33 : EmptyDefaultItem(copy.EmptyDefaultItem),
34 ApplicatorApertureShape(copy.ApplicatorApertureShape),
35 ApplicatorOpening(copy.ApplicatorOpening),
36 ApplicatorOpeningX(copy.ApplicatorOpeningX),
37 ApplicatorOpeningY(copy.ApplicatorOpeningY)
38 {
39 }
40
41
~Item()42 DRTApplicatorGeometrySequence::Item::~Item()
43 {
44 }
45
46
operator =(const Item & copy)47 DRTApplicatorGeometrySequence::Item &DRTApplicatorGeometrySequence::Item::operator=(const Item ©)
48 {
49 if (this != ©)
50 {
51 EmptyDefaultItem = copy.EmptyDefaultItem;
52 ApplicatorApertureShape = copy.ApplicatorApertureShape;
53 ApplicatorOpening = copy.ApplicatorOpening;
54 ApplicatorOpeningX = copy.ApplicatorOpeningX;
55 ApplicatorOpeningY = copy.ApplicatorOpeningY;
56 }
57 return *this;
58 }
59
60
clear()61 void DRTApplicatorGeometrySequence::Item::clear()
62 {
63 if (!EmptyDefaultItem)
64 {
65 /* clear all DICOM attributes */
66 ApplicatorApertureShape.clear();
67 ApplicatorOpening.clear();
68 ApplicatorOpeningX.clear();
69 ApplicatorOpeningY.clear();
70 }
71 }
72
73
isEmpty()74 OFBool DRTApplicatorGeometrySequence::Item::isEmpty()
75 {
76 return ApplicatorApertureShape.isEmpty() &&
77 ApplicatorOpening.isEmpty() &&
78 ApplicatorOpeningX.isEmpty() &&
79 ApplicatorOpeningY.isEmpty();
80 }
81
82
isValid() const83 OFBool DRTApplicatorGeometrySequence::Item::isValid() const
84 {
85 return !EmptyDefaultItem;
86 }
87
88
read(DcmItem & item)89 OFCondition DRTApplicatorGeometrySequence::Item::read(DcmItem &item)
90 {
91 OFCondition result = EC_IllegalCall;
92 if (!EmptyDefaultItem)
93 {
94 /* re-initialize object */
95 clear();
96 getAndCheckElementFromDataset(item, ApplicatorApertureShape, "1", "1", "ApplicatorGeometrySequence");
97 getAndCheckElementFromDataset(item, ApplicatorOpening, "1", "1C", "ApplicatorGeometrySequence");
98 getAndCheckElementFromDataset(item, ApplicatorOpeningX, "1", "1C", "ApplicatorGeometrySequence");
99 getAndCheckElementFromDataset(item, ApplicatorOpeningY, "1", "1C", "ApplicatorGeometrySequence");
100 result = EC_Normal;
101 }
102 return result;
103 }
104
105
write(DcmItem & item)106 OFCondition DRTApplicatorGeometrySequence::Item::write(DcmItem &item)
107 {
108 OFCondition result = EC_IllegalCall;
109 if (!EmptyDefaultItem)
110 {
111 result = EC_Normal;
112 addElementToDataset(result, item, new DcmCodeString(ApplicatorApertureShape), "1", "1", "ApplicatorGeometrySequence");
113 addElementToDataset(result, item, new DcmFloatingPointSingle(ApplicatorOpening), "1", "1C", "ApplicatorGeometrySequence");
114 addElementToDataset(result, item, new DcmFloatingPointSingle(ApplicatorOpeningX), "1", "1C", "ApplicatorGeometrySequence");
115 addElementToDataset(result, item, new DcmFloatingPointSingle(ApplicatorOpeningY), "1", "1C", "ApplicatorGeometrySequence");
116 }
117 return result;
118 }
119
120
getApplicatorApertureShape(OFString & value,const signed long pos) const121 OFCondition DRTApplicatorGeometrySequence::Item::getApplicatorApertureShape(OFString &value, const signed long pos) const
122 {
123 if (EmptyDefaultItem)
124 return EC_IllegalCall;
125 else
126 return getStringValueFromElement(ApplicatorApertureShape, value, pos);
127 }
128
129
getApplicatorOpening(Float32 & value,const unsigned long pos) const130 OFCondition DRTApplicatorGeometrySequence::Item::getApplicatorOpening(Float32 &value, const unsigned long pos) const
131 {
132 if (EmptyDefaultItem)
133 return EC_IllegalCall;
134 else
135 return OFconst_cast(DcmFloatingPointSingle &, ApplicatorOpening).getFloat32(value, pos);
136 }
137
138
getApplicatorOpeningX(Float32 & value,const unsigned long pos) const139 OFCondition DRTApplicatorGeometrySequence::Item::getApplicatorOpeningX(Float32 &value, const unsigned long pos) const
140 {
141 if (EmptyDefaultItem)
142 return EC_IllegalCall;
143 else
144 return OFconst_cast(DcmFloatingPointSingle &, ApplicatorOpeningX).getFloat32(value, pos);
145 }
146
147
getApplicatorOpeningY(Float32 & value,const unsigned long pos) const148 OFCondition DRTApplicatorGeometrySequence::Item::getApplicatorOpeningY(Float32 &value, const unsigned long pos) const
149 {
150 if (EmptyDefaultItem)
151 return EC_IllegalCall;
152 else
153 return OFconst_cast(DcmFloatingPointSingle &, ApplicatorOpeningY).getFloat32(value, pos);
154 }
155
156
setApplicatorApertureShape(const OFString & value,const OFBool check)157 OFCondition DRTApplicatorGeometrySequence::Item::setApplicatorApertureShape(const OFString &value, const OFBool check)
158 {
159 OFCondition result = EC_IllegalCall;
160 if (!EmptyDefaultItem)
161 {
162 result = (check) ? DcmCodeString::checkStringValue(value, "1") : EC_Normal;
163 if (result.good())
164 result = ApplicatorApertureShape.putOFStringArray(value);
165 }
166 return result;
167 }
168
169
setApplicatorOpening(const Float32 value,const unsigned long pos)170 OFCondition DRTApplicatorGeometrySequence::Item::setApplicatorOpening(const Float32 value, const unsigned long pos)
171 {
172 if (EmptyDefaultItem)
173 return EC_IllegalCall;
174 else
175 return ApplicatorOpening.putFloat32(value, pos);
176 }
177
178
setApplicatorOpeningX(const Float32 value,const unsigned long pos)179 OFCondition DRTApplicatorGeometrySequence::Item::setApplicatorOpeningX(const Float32 value, const unsigned long pos)
180 {
181 if (EmptyDefaultItem)
182 return EC_IllegalCall;
183 else
184 return ApplicatorOpeningX.putFloat32(value, pos);
185 }
186
187
setApplicatorOpeningY(const Float32 value,const unsigned long pos)188 OFCondition DRTApplicatorGeometrySequence::Item::setApplicatorOpeningY(const Float32 value, const unsigned long pos)
189 {
190 if (EmptyDefaultItem)
191 return EC_IllegalCall;
192 else
193 return ApplicatorOpeningY.putFloat32(value, pos);
194 }
195
196
197 // --- sequence class ---
198
DRTApplicatorGeometrySequence(const OFBool emptyDefaultSequence)199 DRTApplicatorGeometrySequence::DRTApplicatorGeometrySequence(const OFBool emptyDefaultSequence)
200 : EmptyDefaultSequence(emptyDefaultSequence),
201 SequenceOfItems(),
202 CurrentItem(),
203 EmptyItem(OFTrue /*emptyDefaultItem*/)
204 {
205 CurrentItem = SequenceOfItems.end();
206 }
207
208
DRTApplicatorGeometrySequence(const DRTApplicatorGeometrySequence & copy)209 DRTApplicatorGeometrySequence::DRTApplicatorGeometrySequence(const DRTApplicatorGeometrySequence ©)
210 : EmptyDefaultSequence(copy.EmptyDefaultSequence),
211 SequenceOfItems(),
212 CurrentItem(),
213 EmptyItem(OFTrue /*emptyDefaultItem*/)
214 {
215 /* create a copy of the internal sequence of items */
216 Item *item = NULL;
217 OFListConstIterator(Item *) current = copy.SequenceOfItems.begin();
218 const OFListConstIterator(Item *) last = copy.SequenceOfItems.end();
219 while (current != last)
220 {
221 item = new Item(**current);
222 if (item != NULL)
223 {
224 SequenceOfItems.push_back(item);
225 } else {
226 /* memory exhausted, there is nothing we can do about it */
227 break;
228 }
229 ++current;
230 }
231 CurrentItem = SequenceOfItems.begin();
232 }
233
234
operator =(const DRTApplicatorGeometrySequence & copy)235 DRTApplicatorGeometrySequence &DRTApplicatorGeometrySequence::operator=(const DRTApplicatorGeometrySequence ©)
236 {
237 if (this != ©)
238 {
239 clear();
240 EmptyDefaultSequence = copy.EmptyDefaultSequence;
241 /* create a copy of the internal sequence of items */
242 Item *item = NULL;
243 OFListConstIterator(Item *) current = copy.SequenceOfItems.begin();
244 const OFListConstIterator(Item *) last = copy.SequenceOfItems.end();
245 while (current != last)
246 {
247 item = new Item(**current);
248 if (item != NULL)
249 {
250 SequenceOfItems.push_back(item);
251 } else {
252 /* memory exhausted, there is nothing we can do about it */
253 break;
254 }
255 ++current;
256 }
257 CurrentItem = SequenceOfItems.begin();
258 }
259 return *this;
260 }
261
262
~DRTApplicatorGeometrySequence()263 DRTApplicatorGeometrySequence::~DRTApplicatorGeometrySequence()
264 {
265 clear();
266 }
267
268
clear()269 void DRTApplicatorGeometrySequence::clear()
270 {
271 if (!EmptyDefaultSequence)
272 {
273 CurrentItem = SequenceOfItems.begin();
274 const OFListConstIterator(Item *) last = SequenceOfItems.end();
275 /* delete all items and free memory */
276 while (CurrentItem != last)
277 {
278 delete (*CurrentItem);
279 CurrentItem = SequenceOfItems.erase(CurrentItem);
280 }
281 /* make sure that the list is empty */
282 SequenceOfItems.clear();
283 CurrentItem = SequenceOfItems.end();
284 }
285 }
286
287
isEmpty()288 OFBool DRTApplicatorGeometrySequence::isEmpty()
289 {
290 return SequenceOfItems.empty();
291 }
292
293
isValid() const294 OFBool DRTApplicatorGeometrySequence::isValid() const
295 {
296 return !EmptyDefaultSequence;
297 }
298
299
getNumberOfItems() const300 size_t DRTApplicatorGeometrySequence::getNumberOfItems() const
301 {
302 return SequenceOfItems.size();
303 }
304
305
gotoFirstItem()306 OFCondition DRTApplicatorGeometrySequence::gotoFirstItem()
307 {
308 OFCondition result = EC_IllegalCall;
309 if (!SequenceOfItems.empty())
310 {
311 CurrentItem = SequenceOfItems.begin();
312 result = EC_Normal;
313 }
314 return result;
315 }
316
317
gotoNextItem()318 OFCondition DRTApplicatorGeometrySequence::gotoNextItem()
319 {
320 OFCondition result = EC_IllegalCall;
321 if (CurrentItem != SequenceOfItems.end())
322 {
323 ++CurrentItem;
324 result = EC_Normal;
325 }
326 return result;
327 }
328
329
gotoItem(const size_t num,OFListIterator (Item *)& iterator)330 OFCondition DRTApplicatorGeometrySequence::gotoItem(const size_t num, OFListIterator(Item *) &iterator)
331 {
332 OFCondition result = EC_IllegalCall;
333 if (!SequenceOfItems.empty())
334 {
335 size_t idx = num + 1;
336 iterator = SequenceOfItems.begin();
337 const OFListConstIterator(Item *) last = SequenceOfItems.end();
338 while ((--idx > 0) && (iterator != last))
339 ++iterator;
340 /* specified list item found? */
341 if ((idx == 0) && (iterator != last))
342 result = EC_Normal;
343 else
344 result = EC_IllegalParameter;
345 }
346 return result;
347 }
348
349
gotoItem(const size_t num,OFListConstIterator (Item *)& iterator) const350 OFCondition DRTApplicatorGeometrySequence::gotoItem(const size_t num, OFListConstIterator(Item *) &iterator) const
351 {
352 OFCondition result = EC_IllegalCall;
353 if (!SequenceOfItems.empty())
354 {
355 size_t idx = num + 1;
356 iterator = SequenceOfItems.begin();
357 const OFListConstIterator(Item *) last = SequenceOfItems.end();
358 while ((--idx > 0) && (iterator != last))
359 ++iterator;
360 /* specified list item found? */
361 if ((idx == 0) && (iterator != last))
362 result = EC_Normal;
363 else
364 result = EC_IllegalParameter;
365 }
366 return result;
367 }
368
369
gotoItem(const size_t num)370 OFCondition DRTApplicatorGeometrySequence::gotoItem(const size_t num)
371 {
372 return gotoItem(num, CurrentItem);
373 }
374
375
getCurrentItem(Item * & item) const376 OFCondition DRTApplicatorGeometrySequence::getCurrentItem(Item *&item) const
377 {
378 OFCondition result = EC_IllegalCall;
379 if (CurrentItem != SequenceOfItems.end())
380 {
381 item = *CurrentItem;
382 result = EC_Normal;
383 }
384 return result;
385 }
386
387
getCurrentItem()388 DRTApplicatorGeometrySequence::Item &DRTApplicatorGeometrySequence::getCurrentItem()
389 {
390 if (CurrentItem != SequenceOfItems.end())
391 return **CurrentItem;
392 else
393 return EmptyItem;
394 }
395
396
getCurrentItem() const397 const DRTApplicatorGeometrySequence::Item &DRTApplicatorGeometrySequence::getCurrentItem() const
398 {
399 if (CurrentItem != SequenceOfItems.end())
400 return **CurrentItem;
401 else
402 return EmptyItem;
403 }
404
405
getItem(const size_t num,Item * & item)406 OFCondition DRTApplicatorGeometrySequence::getItem(const size_t num, Item *&item)
407 {
408 OFListIterator(Item *) iterator;
409 OFCondition result = gotoItem(num, iterator);
410 if (result.good())
411 item = *iterator;
412 return result;
413 }
414
415
getItem(const size_t num)416 DRTApplicatorGeometrySequence::Item &DRTApplicatorGeometrySequence::getItem(const size_t num)
417 {
418 OFListIterator(Item *) iterator;
419 if (gotoItem(num, iterator).good())
420 return **iterator;
421 else
422 return EmptyItem;
423 }
424
425
getItem(const size_t num) const426 const DRTApplicatorGeometrySequence::Item &DRTApplicatorGeometrySequence::getItem(const size_t num) const
427 {
428 OFListConstIterator(Item *) iterator;
429 if (gotoItem(num, iterator).good())
430 return **iterator;
431 else
432 return EmptyItem;
433 }
434
435
operator [](const size_t num)436 DRTApplicatorGeometrySequence::Item &DRTApplicatorGeometrySequence::operator[](const size_t num)
437 {
438 return getItem(num);
439 }
440
441
operator [](const size_t num) const442 const DRTApplicatorGeometrySequence::Item &DRTApplicatorGeometrySequence::operator[](const size_t num) const
443 {
444 return getItem(num);
445 }
446
447
addItem(Item * & item)448 OFCondition DRTApplicatorGeometrySequence::addItem(Item *&item)
449 {
450 OFCondition result = EC_IllegalCall;
451 if (!EmptyDefaultSequence)
452 {
453 item = new Item();
454 if (item != NULL)
455 {
456 SequenceOfItems.push_back(item);
457 result = EC_Normal;
458 } else
459 result = EC_MemoryExhausted;
460 }
461 return result;
462 }
463
464
insertItem(const size_t pos,Item * & item)465 OFCondition DRTApplicatorGeometrySequence::insertItem(const size_t pos, Item *&item)
466 {
467 OFCondition result = EC_IllegalCall;
468 if (!EmptyDefaultSequence)
469 {
470 OFListIterator(Item *) iterator;
471 result = gotoItem(pos, iterator);
472 if (result.good())
473 {
474 item = new Item();
475 if (item != NULL)
476 {
477 SequenceOfItems.insert(iterator, 1, item);
478 result = EC_Normal;
479 } else
480 result = EC_MemoryExhausted;
481 } else
482 result = addItem(item);
483 }
484 return result;
485 }
486
487
removeItem(const size_t pos)488 OFCondition DRTApplicatorGeometrySequence::removeItem(const size_t pos)
489 {
490 OFCondition result = EC_IllegalCall;
491 if (!EmptyDefaultSequence)
492 {
493 OFListIterator(Item *) iterator;
494 if (gotoItem(pos, iterator).good())
495 {
496 delete *iterator;
497 iterator = SequenceOfItems.erase(iterator);
498 result = EC_Normal;
499 } else
500 result = EC_IllegalParameter;
501 }
502 return result;
503 }
504
505
read(DcmItem & dataset,const OFString & card,const OFString & type,const char * moduleName)506 OFCondition DRTApplicatorGeometrySequence::read(DcmItem &dataset,
507 const OFString &card,
508 const OFString &type,
509 const char *moduleName)
510 {
511 OFCondition result = EC_IllegalCall;
512 if (!EmptyDefaultSequence)
513 {
514 /* re-initialize object */
515 clear();
516 /* retrieve sequence element from dataset */
517 DcmSequenceOfItems *sequence;
518 result = dataset.findAndGetSequence(DCM_ApplicatorGeometrySequence, sequence);
519 if (sequence != NULL)
520 {
521 if (checkElementValue(*sequence, card, type, result, moduleName))
522 {
523 DcmStack stack;
524 OFBool first = OFTrue;
525 /* iterate over all sequence items */
526 while (result.good() && sequence->nextObject(stack, first /*intoSub*/).good())
527 {
528 DcmItem *ditem = OFstatic_cast(DcmItem *, stack.top());
529 if (ditem != NULL)
530 {
531 Item *item = new Item();
532 if (item != NULL)
533 {
534 result = item->read(*ditem);
535 if (result.good())
536 {
537 /* append new item to the end of the list */
538 SequenceOfItems.push_back(item);
539 first = OFFalse;
540 }
541 } else
542 result = EC_MemoryExhausted;
543 } else
544 result = EC_CorruptedData;
545 }
546 }
547 } else {
548 DcmSequenceOfItems element(DCM_ApplicatorGeometrySequence);
549 checkElementValue(element, card, type, result, moduleName);
550 }
551 }
552 return result;
553 }
554
555
write(DcmItem & dataset,const OFString & card,const OFString & type,const char * moduleName)556 OFCondition DRTApplicatorGeometrySequence::write(DcmItem &dataset,
557 const OFString &card,
558 const OFString &type,
559 const char *moduleName)
560 {
561 OFCondition result = EC_IllegalCall;
562 if (!EmptyDefaultSequence)
563 {
564 result = EC_MemoryExhausted;
565 DcmSequenceOfItems *sequence = new DcmSequenceOfItems(DCM_ApplicatorGeometrySequence);
566 if (sequence != NULL)
567 {
568 result = EC_Normal;
569 /* an empty optional sequence is not written */
570 if ((type == "2") || !SequenceOfItems.empty())
571 {
572 OFListIterator(Item *) iterator = SequenceOfItems.begin();
573 const OFListConstIterator(Item *) last = SequenceOfItems.end();
574 /* iterate over all sequence items */
575 while (result.good() && (iterator != last))
576 {
577 DcmItem *item = new DcmItem();
578 if (item != NULL)
579 {
580 /* append new item to the end of the sequence */
581 result = sequence->append(item);
582 if (result.good())
583 {
584 result = (*iterator)->write(*item);
585 ++iterator;
586 } else
587 delete item;
588 } else
589 result = EC_MemoryExhausted;
590 }
591 if (result.good())
592 {
593 /* insert sequence element into the dataset */
594 result = dataset.insert(sequence, OFTrue /*replaceOld*/);
595 }
596 if (DCM_dcmrtLogger.isEnabledFor(OFLogger::WARN_LOG_LEVEL))
597 checkElementValue(*sequence, card, type, result, moduleName);
598 if (result.good())
599 {
600 /* forget reference to sequence object (avoid deletion below) */
601 sequence = NULL;
602 }
603 }
604 else if (type == "1")
605 {
606 /* empty type 1 sequence not allowed */
607 result = RT_EC_InvalidValue;
608 if (DCM_dcmrtLogger.isEnabledFor(OFLogger::WARN_LOG_LEVEL))
609 checkElementValue(*sequence, card, type, result, moduleName);
610 }
611 /* delete sequence (if not inserted into the dataset) */
612 delete sequence;
613 }
614 }
615 return result;
616 }
617
618
619 // end of source file
620