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