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 DRTBreedRegistryCodeSequence
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/drtbrcss.h"
18 
19 
20 // --- item class ---
21 
Item(const OFBool emptyDefaultItem)22 DRTBreedRegistryCodeSequence::Item::Item(const OFBool emptyDefaultItem)
23   : EmptyDefaultItem(emptyDefaultItem),
24     CodeMeaning(DCM_CodeMeaning),
25     CodeValue(DCM_CodeValue),
26     CodingSchemeDesignator(DCM_CodingSchemeDesignator),
27     CodingSchemeVersion(DCM_CodingSchemeVersion),
28     ContextGroupExtensionCreatorUID(DCM_ContextGroupExtensionCreatorUID),
29     ContextGroupExtensionFlag(DCM_ContextGroupExtensionFlag),
30     ContextGroupLocalVersion(DCM_ContextGroupLocalVersion),
31     ContextGroupVersion(DCM_ContextGroupVersion),
32     ContextIdentifier(DCM_ContextIdentifier),
33     ContextUID(DCM_ContextUID),
34     EquivalentCodeSequence(emptyDefaultItem /*emptyDefaultSequence*/),
35     LongCodeValue(DCM_LongCodeValue),
36     MappingResource(DCM_MappingResource),
37     MappingResourceName(DCM_MappingResourceName),
38     MappingResourceUID(DCM_MappingResourceUID),
39     URNCodeValue(DCM_URNCodeValue)
40 {
41 }
42 
43 
Item(const Item & copy)44 DRTBreedRegistryCodeSequence::Item::Item(const Item &copy)
45   : EmptyDefaultItem(copy.EmptyDefaultItem),
46     CodeMeaning(copy.CodeMeaning),
47     CodeValue(copy.CodeValue),
48     CodingSchemeDesignator(copy.CodingSchemeDesignator),
49     CodingSchemeVersion(copy.CodingSchemeVersion),
50     ContextGroupExtensionCreatorUID(copy.ContextGroupExtensionCreatorUID),
51     ContextGroupExtensionFlag(copy.ContextGroupExtensionFlag),
52     ContextGroupLocalVersion(copy.ContextGroupLocalVersion),
53     ContextGroupVersion(copy.ContextGroupVersion),
54     ContextIdentifier(copy.ContextIdentifier),
55     ContextUID(copy.ContextUID),
56     EquivalentCodeSequence(copy.EquivalentCodeSequence),
57     LongCodeValue(copy.LongCodeValue),
58     MappingResource(copy.MappingResource),
59     MappingResourceName(copy.MappingResourceName),
60     MappingResourceUID(copy.MappingResourceUID),
61     URNCodeValue(copy.URNCodeValue)
62 {
63 }
64 
65 
~Item()66 DRTBreedRegistryCodeSequence::Item::~Item()
67 {
68 }
69 
70 
operator =(const Item & copy)71 DRTBreedRegistryCodeSequence::Item &DRTBreedRegistryCodeSequence::Item::operator=(const Item &copy)
72 {
73     if (this != &copy)
74     {
75         EmptyDefaultItem = copy.EmptyDefaultItem;
76         CodeMeaning = copy.CodeMeaning;
77         CodeValue = copy.CodeValue;
78         CodingSchemeDesignator = copy.CodingSchemeDesignator;
79         CodingSchemeVersion = copy.CodingSchemeVersion;
80         ContextGroupExtensionCreatorUID = copy.ContextGroupExtensionCreatorUID;
81         ContextGroupExtensionFlag = copy.ContextGroupExtensionFlag;
82         ContextGroupLocalVersion = copy.ContextGroupLocalVersion;
83         ContextGroupVersion = copy.ContextGroupVersion;
84         ContextIdentifier = copy.ContextIdentifier;
85         ContextUID = copy.ContextUID;
86         EquivalentCodeSequence = copy.EquivalentCodeSequence;
87         LongCodeValue = copy.LongCodeValue;
88         MappingResource = copy.MappingResource;
89         MappingResourceName = copy.MappingResourceName;
90         MappingResourceUID = copy.MappingResourceUID;
91         URNCodeValue = copy.URNCodeValue;
92     }
93     return *this;
94 }
95 
96 
clear()97 void DRTBreedRegistryCodeSequence::Item::clear()
98 {
99     if (!EmptyDefaultItem)
100     {
101         /* clear all DICOM attributes */
102         CodeValue.clear();
103         CodingSchemeDesignator.clear();
104         CodingSchemeVersion.clear();
105         CodeMeaning.clear();
106         LongCodeValue.clear();
107         URNCodeValue.clear();
108         EquivalentCodeSequence.clear();
109         ContextIdentifier.clear();
110         ContextUID.clear();
111         MappingResource.clear();
112         MappingResourceUID.clear();
113         MappingResourceName.clear();
114         ContextGroupVersion.clear();
115         ContextGroupExtensionFlag.clear();
116         ContextGroupLocalVersion.clear();
117         ContextGroupExtensionCreatorUID.clear();
118     }
119 }
120 
121 
isEmpty()122 OFBool DRTBreedRegistryCodeSequence::Item::isEmpty()
123 {
124     return CodeValue.isEmpty() &&
125            CodingSchemeDesignator.isEmpty() &&
126            CodingSchemeVersion.isEmpty() &&
127            CodeMeaning.isEmpty() &&
128            LongCodeValue.isEmpty() &&
129            URNCodeValue.isEmpty() &&
130            EquivalentCodeSequence.isEmpty() &&
131            ContextIdentifier.isEmpty() &&
132            ContextUID.isEmpty() &&
133            MappingResource.isEmpty() &&
134            MappingResourceUID.isEmpty() &&
135            MappingResourceName.isEmpty() &&
136            ContextGroupVersion.isEmpty() &&
137            ContextGroupExtensionFlag.isEmpty() &&
138            ContextGroupLocalVersion.isEmpty() &&
139            ContextGroupExtensionCreatorUID.isEmpty();
140 }
141 
142 
isValid() const143 OFBool DRTBreedRegistryCodeSequence::Item::isValid() const
144 {
145     return !EmptyDefaultItem;
146 }
147 
148 
read(DcmItem & item)149 OFCondition DRTBreedRegistryCodeSequence::Item::read(DcmItem &item)
150 {
151     OFCondition result = EC_IllegalCall;
152     if (!EmptyDefaultItem)
153     {
154         /* re-initialize object */
155         clear();
156         getAndCheckElementFromDataset(item, CodeValue, "1", "1C", "BreedRegistryCodeSequence");
157         getAndCheckElementFromDataset(item, CodingSchemeDesignator, "1", "1C", "BreedRegistryCodeSequence");
158         getAndCheckElementFromDataset(item, CodingSchemeVersion, "1", "1C", "BreedRegistryCodeSequence");
159         getAndCheckElementFromDataset(item, CodeMeaning, "1", "1", "BreedRegistryCodeSequence");
160         getAndCheckElementFromDataset(item, LongCodeValue, "1", "1C", "BreedRegistryCodeSequence");
161         getAndCheckElementFromDataset(item, URNCodeValue, "1", "1C", "BreedRegistryCodeSequence");
162         EquivalentCodeSequence.read(item, "1-n", "3", "BreedRegistryCodeSequence");
163         getAndCheckElementFromDataset(item, ContextIdentifier, "1", "3", "BreedRegistryCodeSequence");
164         getAndCheckElementFromDataset(item, ContextUID, "1", "3", "BreedRegistryCodeSequence");
165         getAndCheckElementFromDataset(item, MappingResource, "1", "1C", "BreedRegistryCodeSequence");
166         getAndCheckElementFromDataset(item, MappingResourceUID, "1", "3", "BreedRegistryCodeSequence");
167         getAndCheckElementFromDataset(item, MappingResourceName, "1", "3", "BreedRegistryCodeSequence");
168         getAndCheckElementFromDataset(item, ContextGroupVersion, "1", "1C", "BreedRegistryCodeSequence");
169         getAndCheckElementFromDataset(item, ContextGroupExtensionFlag, "1", "3", "BreedRegistryCodeSequence");
170         getAndCheckElementFromDataset(item, ContextGroupLocalVersion, "1", "1C", "BreedRegistryCodeSequence");
171         getAndCheckElementFromDataset(item, ContextGroupExtensionCreatorUID, "1", "1C", "BreedRegistryCodeSequence");
172         result = EC_Normal;
173     }
174     return result;
175 }
176 
177 
write(DcmItem & item)178 OFCondition DRTBreedRegistryCodeSequence::Item::write(DcmItem &item)
179 {
180     OFCondition result = EC_IllegalCall;
181     if (!EmptyDefaultItem)
182     {
183         result = EC_Normal;
184         addElementToDataset(result, item, new DcmShortString(CodeValue), "1", "1C", "BreedRegistryCodeSequence");
185         addElementToDataset(result, item, new DcmShortString(CodingSchemeDesignator), "1", "1C", "BreedRegistryCodeSequence");
186         addElementToDataset(result, item, new DcmShortString(CodingSchemeVersion), "1", "1C", "BreedRegistryCodeSequence");
187         addElementToDataset(result, item, new DcmLongString(CodeMeaning), "1", "1", "BreedRegistryCodeSequence");
188         addElementToDataset(result, item, new DcmUnlimitedCharacters(LongCodeValue), "1", "1C", "BreedRegistryCodeSequence");
189         addElementToDataset(result, item, new DcmUniversalResourceIdentifierOrLocator(URNCodeValue), "1", "1C", "BreedRegistryCodeSequence");
190         if (result.good()) result = EquivalentCodeSequence.write(item, "1-n", "3", "BreedRegistryCodeSequence");
191         addElementToDataset(result, item, new DcmCodeString(ContextIdentifier), "1", "3", "BreedRegistryCodeSequence");
192         addElementToDataset(result, item, new DcmUniqueIdentifier(ContextUID), "1", "3", "BreedRegistryCodeSequence");
193         addElementToDataset(result, item, new DcmCodeString(MappingResource), "1", "1C", "BreedRegistryCodeSequence");
194         addElementToDataset(result, item, new DcmUniqueIdentifier(MappingResourceUID), "1", "3", "BreedRegistryCodeSequence");
195         addElementToDataset(result, item, new DcmLongString(MappingResourceName), "1", "3", "BreedRegistryCodeSequence");
196         addElementToDataset(result, item, new DcmDateTime(ContextGroupVersion), "1", "1C", "BreedRegistryCodeSequence");
197         addElementToDataset(result, item, new DcmCodeString(ContextGroupExtensionFlag), "1", "3", "BreedRegistryCodeSequence");
198         addElementToDataset(result, item, new DcmDateTime(ContextGroupLocalVersion), "1", "1C", "BreedRegistryCodeSequence");
199         addElementToDataset(result, item, new DcmUniqueIdentifier(ContextGroupExtensionCreatorUID), "1", "1C", "BreedRegistryCodeSequence");
200     }
201     return result;
202 }
203 
204 
getCodeMeaning(OFString & value,const signed long pos) const205 OFCondition DRTBreedRegistryCodeSequence::Item::getCodeMeaning(OFString &value, const signed long pos) const
206 {
207     if (EmptyDefaultItem)
208         return EC_IllegalCall;
209     else
210         return getStringValueFromElement(CodeMeaning, value, pos);
211 }
212 
213 
getCodeValue(OFString & value,const signed long pos) const214 OFCondition DRTBreedRegistryCodeSequence::Item::getCodeValue(OFString &value, const signed long pos) const
215 {
216     if (EmptyDefaultItem)
217         return EC_IllegalCall;
218     else
219         return getStringValueFromElement(CodeValue, value, pos);
220 }
221 
222 
getCodingSchemeDesignator(OFString & value,const signed long pos) const223 OFCondition DRTBreedRegistryCodeSequence::Item::getCodingSchemeDesignator(OFString &value, const signed long pos) const
224 {
225     if (EmptyDefaultItem)
226         return EC_IllegalCall;
227     else
228         return getStringValueFromElement(CodingSchemeDesignator, value, pos);
229 }
230 
231 
getCodingSchemeVersion(OFString & value,const signed long pos) const232 OFCondition DRTBreedRegistryCodeSequence::Item::getCodingSchemeVersion(OFString &value, const signed long pos) const
233 {
234     if (EmptyDefaultItem)
235         return EC_IllegalCall;
236     else
237         return getStringValueFromElement(CodingSchemeVersion, value, pos);
238 }
239 
240 
getContextGroupExtensionCreatorUID(OFString & value,const signed long pos) const241 OFCondition DRTBreedRegistryCodeSequence::Item::getContextGroupExtensionCreatorUID(OFString &value, const signed long pos) const
242 {
243     if (EmptyDefaultItem)
244         return EC_IllegalCall;
245     else
246         return getStringValueFromElement(ContextGroupExtensionCreatorUID, value, pos);
247 }
248 
249 
getContextGroupExtensionFlag(OFString & value,const signed long pos) const250 OFCondition DRTBreedRegistryCodeSequence::Item::getContextGroupExtensionFlag(OFString &value, const signed long pos) const
251 {
252     if (EmptyDefaultItem)
253         return EC_IllegalCall;
254     else
255         return getStringValueFromElement(ContextGroupExtensionFlag, value, pos);
256 }
257 
258 
getContextGroupLocalVersion(OFString & value,const signed long pos) const259 OFCondition DRTBreedRegistryCodeSequence::Item::getContextGroupLocalVersion(OFString &value, const signed long pos) const
260 {
261     if (EmptyDefaultItem)
262         return EC_IllegalCall;
263     else
264         return getStringValueFromElement(ContextGroupLocalVersion, value, pos);
265 }
266 
267 
getContextGroupVersion(OFString & value,const signed long pos) const268 OFCondition DRTBreedRegistryCodeSequence::Item::getContextGroupVersion(OFString &value, const signed long pos) const
269 {
270     if (EmptyDefaultItem)
271         return EC_IllegalCall;
272     else
273         return getStringValueFromElement(ContextGroupVersion, value, pos);
274 }
275 
276 
getContextIdentifier(OFString & value,const signed long pos) const277 OFCondition DRTBreedRegistryCodeSequence::Item::getContextIdentifier(OFString &value, const signed long pos) const
278 {
279     if (EmptyDefaultItem)
280         return EC_IllegalCall;
281     else
282         return getStringValueFromElement(ContextIdentifier, value, pos);
283 }
284 
285 
getContextUID(OFString & value,const signed long pos) const286 OFCondition DRTBreedRegistryCodeSequence::Item::getContextUID(OFString &value, const signed long pos) const
287 {
288     if (EmptyDefaultItem)
289         return EC_IllegalCall;
290     else
291         return getStringValueFromElement(ContextUID, value, pos);
292 }
293 
294 
getLongCodeValue(OFString & value,const signed long pos) const295 OFCondition DRTBreedRegistryCodeSequence::Item::getLongCodeValue(OFString &value, const signed long pos) const
296 {
297     if (EmptyDefaultItem)
298         return EC_IllegalCall;
299     else
300         return getStringValueFromElement(LongCodeValue, value, pos);
301 }
302 
303 
getMappingResource(OFString & value,const signed long pos) const304 OFCondition DRTBreedRegistryCodeSequence::Item::getMappingResource(OFString &value, const signed long pos) const
305 {
306     if (EmptyDefaultItem)
307         return EC_IllegalCall;
308     else
309         return getStringValueFromElement(MappingResource, value, pos);
310 }
311 
312 
getMappingResourceName(OFString & value,const signed long pos) const313 OFCondition DRTBreedRegistryCodeSequence::Item::getMappingResourceName(OFString &value, const signed long pos) const
314 {
315     if (EmptyDefaultItem)
316         return EC_IllegalCall;
317     else
318         return getStringValueFromElement(MappingResourceName, value, pos);
319 }
320 
321 
getMappingResourceUID(OFString & value,const signed long pos) const322 OFCondition DRTBreedRegistryCodeSequence::Item::getMappingResourceUID(OFString &value, const signed long pos) const
323 {
324     if (EmptyDefaultItem)
325         return EC_IllegalCall;
326     else
327         return getStringValueFromElement(MappingResourceUID, value, pos);
328 }
329 
330 
getURNCodeValue(OFString & value,const signed long pos) const331 OFCondition DRTBreedRegistryCodeSequence::Item::getURNCodeValue(OFString &value, const signed long pos) const
332 {
333     if (EmptyDefaultItem)
334         return EC_IllegalCall;
335     else
336         return getStringValueFromElement(URNCodeValue, value, pos);
337 }
338 
339 
setCodeMeaning(const OFString & value,const OFBool check)340 OFCondition DRTBreedRegistryCodeSequence::Item::setCodeMeaning(const OFString &value, const OFBool check)
341 {
342     OFCondition result = EC_IllegalCall;
343     if (!EmptyDefaultItem)
344     {
345         result = (check) ? DcmLongString::checkStringValue(value, "1") : EC_Normal;
346         if (result.good())
347             result = CodeMeaning.putOFStringArray(value);
348     }
349     return result;
350 }
351 
352 
setCodeValue(const OFString & value,const OFBool check)353 OFCondition DRTBreedRegistryCodeSequence::Item::setCodeValue(const OFString &value, const OFBool check)
354 {
355     OFCondition result = EC_IllegalCall;
356     if (!EmptyDefaultItem)
357     {
358         result = (check) ? DcmShortString::checkStringValue(value, "1") : EC_Normal;
359         if (result.good())
360             result = CodeValue.putOFStringArray(value);
361     }
362     return result;
363 }
364 
365 
setCodingSchemeDesignator(const OFString & value,const OFBool check)366 OFCondition DRTBreedRegistryCodeSequence::Item::setCodingSchemeDesignator(const OFString &value, const OFBool check)
367 {
368     OFCondition result = EC_IllegalCall;
369     if (!EmptyDefaultItem)
370     {
371         result = (check) ? DcmShortString::checkStringValue(value, "1") : EC_Normal;
372         if (result.good())
373             result = CodingSchemeDesignator.putOFStringArray(value);
374     }
375     return result;
376 }
377 
378 
setCodingSchemeVersion(const OFString & value,const OFBool check)379 OFCondition DRTBreedRegistryCodeSequence::Item::setCodingSchemeVersion(const OFString &value, const OFBool check)
380 {
381     OFCondition result = EC_IllegalCall;
382     if (!EmptyDefaultItem)
383     {
384         result = (check) ? DcmShortString::checkStringValue(value, "1") : EC_Normal;
385         if (result.good())
386             result = CodingSchemeVersion.putOFStringArray(value);
387     }
388     return result;
389 }
390 
391 
setContextGroupExtensionCreatorUID(const OFString & value,const OFBool check)392 OFCondition DRTBreedRegistryCodeSequence::Item::setContextGroupExtensionCreatorUID(const OFString &value, const OFBool check)
393 {
394     OFCondition result = EC_IllegalCall;
395     if (!EmptyDefaultItem)
396     {
397         result = (check) ? DcmUniqueIdentifier::checkStringValue(value, "1") : EC_Normal;
398         if (result.good())
399             result = ContextGroupExtensionCreatorUID.putOFStringArray(value);
400     }
401     return result;
402 }
403 
404 
setContextGroupExtensionFlag(const OFString & value,const OFBool check)405 OFCondition DRTBreedRegistryCodeSequence::Item::setContextGroupExtensionFlag(const OFString &value, const OFBool check)
406 {
407     OFCondition result = EC_IllegalCall;
408     if (!EmptyDefaultItem)
409     {
410         result = (check) ? DcmCodeString::checkStringValue(value, "1") : EC_Normal;
411         if (result.good())
412             result = ContextGroupExtensionFlag.putOFStringArray(value);
413     }
414     return result;
415 }
416 
417 
setContextGroupLocalVersion(const OFString & value,const OFBool check)418 OFCondition DRTBreedRegistryCodeSequence::Item::setContextGroupLocalVersion(const OFString &value, const OFBool check)
419 {
420     OFCondition result = EC_IllegalCall;
421     if (!EmptyDefaultItem)
422     {
423         result = (check) ? DcmDateTime::checkStringValue(value, "1") : EC_Normal;
424         if (result.good())
425             result = ContextGroupLocalVersion.putOFStringArray(value);
426     }
427     return result;
428 }
429 
430 
setContextGroupVersion(const OFString & value,const OFBool check)431 OFCondition DRTBreedRegistryCodeSequence::Item::setContextGroupVersion(const OFString &value, const OFBool check)
432 {
433     OFCondition result = EC_IllegalCall;
434     if (!EmptyDefaultItem)
435     {
436         result = (check) ? DcmDateTime::checkStringValue(value, "1") : EC_Normal;
437         if (result.good())
438             result = ContextGroupVersion.putOFStringArray(value);
439     }
440     return result;
441 }
442 
443 
setContextIdentifier(const OFString & value,const OFBool check)444 OFCondition DRTBreedRegistryCodeSequence::Item::setContextIdentifier(const OFString &value, const OFBool check)
445 {
446     OFCondition result = EC_IllegalCall;
447     if (!EmptyDefaultItem)
448     {
449         result = (check) ? DcmCodeString::checkStringValue(value, "1") : EC_Normal;
450         if (result.good())
451             result = ContextIdentifier.putOFStringArray(value);
452     }
453     return result;
454 }
455 
456 
setContextUID(const OFString & value,const OFBool check)457 OFCondition DRTBreedRegistryCodeSequence::Item::setContextUID(const OFString &value, const OFBool check)
458 {
459     OFCondition result = EC_IllegalCall;
460     if (!EmptyDefaultItem)
461     {
462         result = (check) ? DcmUniqueIdentifier::checkStringValue(value, "1") : EC_Normal;
463         if (result.good())
464             result = ContextUID.putOFStringArray(value);
465     }
466     return result;
467 }
468 
469 
setLongCodeValue(const OFString & value,const OFBool check)470 OFCondition DRTBreedRegistryCodeSequence::Item::setLongCodeValue(const OFString &value, const OFBool check)
471 {
472     OFCondition result = EC_IllegalCall;
473     if (!EmptyDefaultItem)
474     {
475         result = (check) ? DcmUnlimitedCharacters::checkStringValue(value, "1") : EC_Normal;
476         if (result.good())
477             result = LongCodeValue.putOFStringArray(value);
478     }
479     return result;
480 }
481 
482 
setMappingResource(const OFString & value,const OFBool check)483 OFCondition DRTBreedRegistryCodeSequence::Item::setMappingResource(const OFString &value, const OFBool check)
484 {
485     OFCondition result = EC_IllegalCall;
486     if (!EmptyDefaultItem)
487     {
488         result = (check) ? DcmCodeString::checkStringValue(value, "1") : EC_Normal;
489         if (result.good())
490             result = MappingResource.putOFStringArray(value);
491     }
492     return result;
493 }
494 
495 
setMappingResourceName(const OFString & value,const OFBool check)496 OFCondition DRTBreedRegistryCodeSequence::Item::setMappingResourceName(const OFString &value, const OFBool check)
497 {
498     OFCondition result = EC_IllegalCall;
499     if (!EmptyDefaultItem)
500     {
501         result = (check) ? DcmLongString::checkStringValue(value, "1") : EC_Normal;
502         if (result.good())
503             result = MappingResourceName.putOFStringArray(value);
504     }
505     return result;
506 }
507 
508 
setMappingResourceUID(const OFString & value,const OFBool check)509 OFCondition DRTBreedRegistryCodeSequence::Item::setMappingResourceUID(const OFString &value, const OFBool check)
510 {
511     OFCondition result = EC_IllegalCall;
512     if (!EmptyDefaultItem)
513     {
514         result = (check) ? DcmUniqueIdentifier::checkStringValue(value, "1") : EC_Normal;
515         if (result.good())
516             result = MappingResourceUID.putOFStringArray(value);
517     }
518     return result;
519 }
520 
521 
setURNCodeValue(const OFString & value,const OFBool check)522 OFCondition DRTBreedRegistryCodeSequence::Item::setURNCodeValue(const OFString &value, const OFBool check)
523 {
524     OFCondition result = EC_IllegalCall;
525     if (!EmptyDefaultItem)
526     {
527         result = (check) ? DcmUniversalResourceIdentifierOrLocator::checkStringValue(value) : EC_Normal;
528         if (result.good())
529             result = URNCodeValue.putOFStringArray(value);
530     }
531     return result;
532 }
533 
534 
535 // --- sequence class ---
536 
DRTBreedRegistryCodeSequence(const OFBool emptyDefaultSequence)537 DRTBreedRegistryCodeSequence::DRTBreedRegistryCodeSequence(const OFBool emptyDefaultSequence)
538   : EmptyDefaultSequence(emptyDefaultSequence),
539     SequenceOfItems(),
540     CurrentItem(),
541     EmptyItem(OFTrue /*emptyDefaultItem*/)
542 {
543     CurrentItem = SequenceOfItems.end();
544 }
545 
546 
DRTBreedRegistryCodeSequence(const DRTBreedRegistryCodeSequence & copy)547 DRTBreedRegistryCodeSequence::DRTBreedRegistryCodeSequence(const DRTBreedRegistryCodeSequence &copy)
548   : EmptyDefaultSequence(copy.EmptyDefaultSequence),
549     SequenceOfItems(),
550     CurrentItem(),
551     EmptyItem(OFTrue /*emptyDefaultItem*/)
552 {
553     /* create a copy of the internal sequence of items */
554     Item *item = NULL;
555     OFListConstIterator(Item *) current = copy.SequenceOfItems.begin();
556     const OFListConstIterator(Item *) last = copy.SequenceOfItems.end();
557     while (current != last)
558     {
559         item = new Item(**current);
560         if (item != NULL)
561         {
562             SequenceOfItems.push_back(item);
563         } else {
564             /* memory exhausted, there is nothing we can do about it */
565             break;
566         }
567         ++current;
568     }
569     CurrentItem = SequenceOfItems.begin();
570 }
571 
572 
operator =(const DRTBreedRegistryCodeSequence & copy)573 DRTBreedRegistryCodeSequence &DRTBreedRegistryCodeSequence::operator=(const DRTBreedRegistryCodeSequence &copy)
574 {
575     if (this != &copy)
576     {
577         clear();
578         EmptyDefaultSequence = copy.EmptyDefaultSequence;
579         /* create a copy of the internal sequence of items */
580         Item *item = NULL;
581         OFListConstIterator(Item *) current = copy.SequenceOfItems.begin();
582         const OFListConstIterator(Item *) last = copy.SequenceOfItems.end();
583         while (current != last)
584         {
585             item = new Item(**current);
586             if (item != NULL)
587             {
588                 SequenceOfItems.push_back(item);
589             } else {
590                 /* memory exhausted, there is nothing we can do about it */
591                 break;
592             }
593             ++current;
594         }
595         CurrentItem = SequenceOfItems.begin();
596     }
597     return *this;
598 }
599 
600 
~DRTBreedRegistryCodeSequence()601 DRTBreedRegistryCodeSequence::~DRTBreedRegistryCodeSequence()
602 {
603     clear();
604 }
605 
606 
clear()607 void DRTBreedRegistryCodeSequence::clear()
608 {
609     if (!EmptyDefaultSequence)
610     {
611         CurrentItem = SequenceOfItems.begin();
612         const OFListConstIterator(Item *) last = SequenceOfItems.end();
613         /* delete all items and free memory */
614         while (CurrentItem != last)
615         {
616             delete (*CurrentItem);
617             CurrentItem = SequenceOfItems.erase(CurrentItem);
618         }
619         /* make sure that the list is empty */
620         SequenceOfItems.clear();
621         CurrentItem = SequenceOfItems.end();
622     }
623 }
624 
625 
isEmpty()626 OFBool DRTBreedRegistryCodeSequence::isEmpty()
627 {
628     return SequenceOfItems.empty();
629 }
630 
631 
isValid() const632 OFBool DRTBreedRegistryCodeSequence::isValid() const
633 {
634     return !EmptyDefaultSequence;
635 }
636 
637 
getNumberOfItems() const638 size_t DRTBreedRegistryCodeSequence::getNumberOfItems() const
639 {
640     return SequenceOfItems.size();
641 }
642 
643 
gotoFirstItem()644 OFCondition DRTBreedRegistryCodeSequence::gotoFirstItem()
645 {
646     OFCondition result = EC_IllegalCall;
647     if (!SequenceOfItems.empty())
648     {
649         CurrentItem = SequenceOfItems.begin();
650         result = EC_Normal;
651     }
652     return result;
653 }
654 
655 
gotoNextItem()656 OFCondition DRTBreedRegistryCodeSequence::gotoNextItem()
657 {
658     OFCondition result = EC_IllegalCall;
659     if (CurrentItem != SequenceOfItems.end())
660     {
661         ++CurrentItem;
662         result = EC_Normal;
663     }
664     return result;
665 }
666 
667 
gotoItem(const size_t num,OFListIterator (Item *)& iterator)668 OFCondition DRTBreedRegistryCodeSequence::gotoItem(const size_t num, OFListIterator(Item *) &iterator)
669 {
670     OFCondition result = EC_IllegalCall;
671     if (!SequenceOfItems.empty())
672     {
673         size_t idx = num + 1;
674         iterator = SequenceOfItems.begin();
675         const OFListConstIterator(Item *) last = SequenceOfItems.end();
676         while ((--idx > 0) && (iterator != last))
677             ++iterator;
678         /* specified list item found? */
679         if ((idx == 0) && (iterator != last))
680             result = EC_Normal;
681         else
682             result = EC_IllegalParameter;
683     }
684     return result;
685 }
686 
687 
gotoItem(const size_t num,OFListConstIterator (Item *)& iterator) const688 OFCondition DRTBreedRegistryCodeSequence::gotoItem(const size_t num, OFListConstIterator(Item *) &iterator) const
689 {
690     OFCondition result = EC_IllegalCall;
691     if (!SequenceOfItems.empty())
692     {
693         size_t idx = num + 1;
694         iterator = SequenceOfItems.begin();
695         const OFListConstIterator(Item *) last = SequenceOfItems.end();
696         while ((--idx > 0) && (iterator != last))
697             ++iterator;
698         /* specified list item found? */
699         if ((idx == 0) && (iterator != last))
700             result = EC_Normal;
701         else
702             result = EC_IllegalParameter;
703     }
704     return result;
705 }
706 
707 
gotoItem(const size_t num)708 OFCondition DRTBreedRegistryCodeSequence::gotoItem(const size_t num)
709 {
710     return gotoItem(num, CurrentItem);
711 }
712 
713 
getCurrentItem(Item * & item) const714 OFCondition DRTBreedRegistryCodeSequence::getCurrentItem(Item *&item) const
715 {
716     OFCondition result = EC_IllegalCall;
717     if (CurrentItem != SequenceOfItems.end())
718     {
719         item = *CurrentItem;
720         result = EC_Normal;
721     }
722     return result;
723 }
724 
725 
getCurrentItem()726 DRTBreedRegistryCodeSequence::Item &DRTBreedRegistryCodeSequence::getCurrentItem()
727 {
728     if (CurrentItem != SequenceOfItems.end())
729         return **CurrentItem;
730     else
731         return EmptyItem;
732 }
733 
734 
getCurrentItem() const735 const DRTBreedRegistryCodeSequence::Item &DRTBreedRegistryCodeSequence::getCurrentItem() const
736 {
737     if (CurrentItem != SequenceOfItems.end())
738         return **CurrentItem;
739     else
740         return EmptyItem;
741 }
742 
743 
getItem(const size_t num,Item * & item)744 OFCondition DRTBreedRegistryCodeSequence::getItem(const size_t num, Item *&item)
745 {
746     OFListIterator(Item *) iterator;
747     OFCondition result = gotoItem(num, iterator);
748     if (result.good())
749         item = *iterator;
750     return result;
751 }
752 
753 
getItem(const size_t num)754 DRTBreedRegistryCodeSequence::Item &DRTBreedRegistryCodeSequence::getItem(const size_t num)
755 {
756     OFListIterator(Item *) iterator;
757     if (gotoItem(num, iterator).good())
758         return **iterator;
759     else
760         return EmptyItem;
761 }
762 
763 
getItem(const size_t num) const764 const DRTBreedRegistryCodeSequence::Item &DRTBreedRegistryCodeSequence::getItem(const size_t num) const
765 {
766     OFListConstIterator(Item *) iterator;
767     if (gotoItem(num, iterator).good())
768         return **iterator;
769     else
770         return EmptyItem;
771 }
772 
773 
operator [](const size_t num)774 DRTBreedRegistryCodeSequence::Item &DRTBreedRegistryCodeSequence::operator[](const size_t num)
775 {
776     return getItem(num);
777 }
778 
779 
operator [](const size_t num) const780 const DRTBreedRegistryCodeSequence::Item &DRTBreedRegistryCodeSequence::operator[](const size_t num) const
781 {
782     return getItem(num);
783 }
784 
785 
addItem(Item * & item)786 OFCondition DRTBreedRegistryCodeSequence::addItem(Item *&item)
787 {
788     OFCondition result = EC_IllegalCall;
789     if (!EmptyDefaultSequence)
790     {
791         item = new Item();
792         if (item != NULL)
793         {
794             SequenceOfItems.push_back(item);
795             result = EC_Normal;
796         } else
797             result = EC_MemoryExhausted;
798     }
799     return result;
800 }
801 
802 
insertItem(const size_t pos,Item * & item)803 OFCondition DRTBreedRegistryCodeSequence::insertItem(const size_t pos, Item *&item)
804 {
805     OFCondition result = EC_IllegalCall;
806     if (!EmptyDefaultSequence)
807     {
808         OFListIterator(Item *) iterator;
809         result = gotoItem(pos, iterator);
810         if (result.good())
811         {
812             item = new Item();
813             if (item != NULL)
814             {
815                 SequenceOfItems.insert(iterator, 1, item);
816                 result = EC_Normal;
817             } else
818                 result = EC_MemoryExhausted;
819         } else
820             result = addItem(item);
821     }
822     return result;
823 }
824 
825 
removeItem(const size_t pos)826 OFCondition DRTBreedRegistryCodeSequence::removeItem(const size_t pos)
827 {
828     OFCondition result = EC_IllegalCall;
829     if (!EmptyDefaultSequence)
830     {
831         OFListIterator(Item *) iterator;
832         if (gotoItem(pos, iterator).good())
833         {
834             delete *iterator;
835             iterator = SequenceOfItems.erase(iterator);
836             result = EC_Normal;
837         } else
838             result = EC_IllegalParameter;
839     }
840     return result;
841 }
842 
843 
read(DcmItem & dataset,const OFString & card,const OFString & type,const char * moduleName)844 OFCondition DRTBreedRegistryCodeSequence::read(DcmItem &dataset,
845                                                const OFString &card,
846                                                const OFString &type,
847                                                const char *moduleName)
848 {
849     OFCondition result = EC_IllegalCall;
850     if (!EmptyDefaultSequence)
851     {
852         /* re-initialize object */
853         clear();
854         /* retrieve sequence element from dataset */
855         DcmSequenceOfItems *sequence;
856         result = dataset.findAndGetSequence(DCM_BreedRegistryCodeSequence, sequence);
857         if (sequence != NULL)
858         {
859             if (checkElementValue(*sequence, card, type, result, moduleName))
860             {
861                 DcmStack stack;
862                 OFBool first = OFTrue;
863                 /* iterate over all sequence items */
864                 while (result.good() && sequence->nextObject(stack, first /*intoSub*/).good())
865                 {
866                     DcmItem *ditem = OFstatic_cast(DcmItem *, stack.top());
867                     if (ditem != NULL)
868                     {
869                         Item *item = new Item();
870                         if (item != NULL)
871                         {
872                             result = item->read(*ditem);
873                             if (result.good())
874                             {
875                                 /* append new item to the end of the list */
876                                 SequenceOfItems.push_back(item);
877                                 first = OFFalse;
878                             }
879                         } else
880                             result = EC_MemoryExhausted;
881                     } else
882                         result = EC_CorruptedData;
883                 }
884             }
885         } else {
886             DcmSequenceOfItems element(DCM_BreedRegistryCodeSequence);
887             checkElementValue(element, card, type, result, moduleName);
888         }
889     }
890     return result;
891 }
892 
893 
write(DcmItem & dataset,const OFString & card,const OFString & type,const char * moduleName)894 OFCondition DRTBreedRegistryCodeSequence::write(DcmItem &dataset,
895                                                 const OFString &card,
896                                                 const OFString &type,
897                                                 const char *moduleName)
898 {
899     OFCondition result = EC_IllegalCall;
900     if (!EmptyDefaultSequence)
901     {
902         result = EC_MemoryExhausted;
903         DcmSequenceOfItems *sequence = new DcmSequenceOfItems(DCM_BreedRegistryCodeSequence);
904         if (sequence != NULL)
905         {
906             result = EC_Normal;
907             /* an empty optional sequence is not written */
908             if ((type == "2") || !SequenceOfItems.empty())
909             {
910                 OFListIterator(Item *) iterator = SequenceOfItems.begin();
911                 const OFListConstIterator(Item *) last = SequenceOfItems.end();
912                 /* iterate over all sequence items */
913                 while (result.good() && (iterator != last))
914                 {
915                     DcmItem *item = new DcmItem();
916                     if (item != NULL)
917                     {
918                         /* append new item to the end of the sequence */
919                         result = sequence->append(item);
920                         if (result.good())
921                         {
922                             result = (*iterator)->write(*item);
923                             ++iterator;
924                         } else
925                             delete item;
926                     } else
927                         result = EC_MemoryExhausted;
928                 }
929                 if (result.good())
930                 {
931                     /* insert sequence element into the dataset */
932                     result = dataset.insert(sequence, OFTrue /*replaceOld*/);
933                 }
934                 if (DCM_dcmrtLogger.isEnabledFor(OFLogger::WARN_LOG_LEVEL))
935                     checkElementValue(*sequence, card, type, result, moduleName);
936                 if (result.good())
937                 {
938                     /* forget reference to sequence object (avoid deletion below) */
939                     sequence = NULL;
940                 }
941             }
942             else if (type == "1")
943             {
944                 /* empty type 1 sequence not allowed */
945                 result = RT_EC_InvalidValue;
946                 if (DCM_dcmrtLogger.isEnabledFor(OFLogger::WARN_LOG_LEVEL))
947                     checkElementValue(*sequence, card, type, result, moduleName);
948             }
949             /* delete sequence (if not inserted into the dataset) */
950             delete sequence;
951         }
952     }
953     return result;
954 }
955 
956 
957 // end of source file
958