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