GDCM 2.2.1

- Main Page
- Related Pages
- Namespaces
- Classes
- Files
- Examples

- File List
- File Members

gdcmDataElement.h
Go to the documentation of this file.
1 /*=========================================================================
2
3 Program: GDCM (Grassroots DICOM). A DICOM library
4
5 Copyright (c) 2006-2011 Mathieu Malaterre
6 All rights reserved.
7 See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
8
9 This software is distributed WITHOUT ANY WARRANTY; without even
10 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
11 PURPOSE. See the above copyright notice for more information.
12
13 =========================================================================*/
14 #ifndef GDCMDATAELEMENT_H
15 #define GDCMDATAELEMENT_H
16
17 #include "gdcmTag.h"
18 #include "gdcmVL.h"
19 #include "gdcmVR.h"
20 #include "gdcmByteValue.h"
21 #include "gdcmSmartPointer.h"
22
23 #include <set>
24
25 namespace gdcm
26 {
27 // Data Element
28 // Contains multiple fields:
29 // -> Tag
30 // -> Optional VR (Explicit Transfer Syntax)
31 // -> ValueLength
32 // -> Value
33 // TODO: This class SHOULD be pure virtual. I dont want a user
34 // to shoot himself in the foot.
35
36 class SequenceOfItems;
37 class SequenceOfFragments;
58 class GDCM_EXPORT DataElement
59 {
60 public:
61 DataElement(const Tag& t = Tag(0), const VL& vl = 0, const VR &vr = VR::INVALID):TagField(t),ValueLengthField(vl),VRField(vr),ValueField(0) {}
62 //DataElement( Attribute const &att );
63
64 friend std::ostream& operator<<(std::ostream &_os, const DataElement &_val);
65
67 const Tag& GetTag() const { return TagField; }
68 Tag& GetTag() { return TagField; }
71 void SetTag(const Tag &t) { TagField = t; }
72
74 const VL& GetVL() const { return ValueLengthField; }
75 VL& GetVL() { return ValueLengthField; }
79 void SetVL(const VL &vl) { ValueLengthField = vl; }
80 void SetVLToUndefined();
81
84 VR const &GetVR() const { return VRField; }
88 void SetVR(VR const &vr) {
89 if( vr.IsVRFile() )
90 VRField = vr;
91 }
92
94 Value const &GetValue() const { return *ValueField; }
95 Value &GetValue() { return *ValueField; }
97 void SetValue(Value const & vl) {
98 //assert( ValueField == 0 );
99 ValueField = vl;
100 ValueLengthField = vl.GetLength();
101 }
103 bool IsEmpty() const { return ValueField == 0 || (GetByteValue() && GetByteValue()->IsEmpty()); }
104
106 void Empty() { ValueField = 0; ValueLengthField = 0; }
107
109 void Clear()
110 {
111 TagField = 0;
112 VRField = VR::INVALID;
113 ValueField = 0;
114 ValueLengthField = 0;
115 }
116
117 // Helper:
123 void SetByteValue(const char *array, VL length)
124 {
125 ByteValue *bv = new ByteValue(array,length);
126 SetValue( *bv );
127 }
130 const ByteValue* GetByteValue() const {
131 // Get the raw pointer from the gdcm::SmartPointer
132 const ByteValue *bv = dynamic_cast<const ByteValue*>(ValueField.GetPointer());
133 return bv; // Will return NULL if not ByteValue
134 }
135
144 GDCM_LEGACY(const SequenceOfItems* GetSequenceOfItems() const)
145 GDCM_LEGACY(SequenceOfItems* GetSequenceOfItems())
146
153 SmartPointer<SequenceOfItems> GetValueAsSQ() const;
154
157 const SequenceOfFragments* GetSequenceOfFragments() const;
158
160 bool IsUndefinedLength() const {
161 return ValueLengthField.IsUndefined();
162 }
163
164 DataElement(const DataElement &_val)
165 {
166 if( this != &_val)
167 {
168 *this = _val;
169 }
170 }
171
172 bool operator<(const DataElement &de) const
173 {
174 return GetTag() < de.GetTag();
175 }
176 DataElement &operator=(const DataElement &de)
177 {
178 TagField = de.TagField;
179 ValueLengthField = de.ValueLengthField;
180 VRField = de.VRField;
181 ValueField = de.ValueField; // Pointer copy
182 return *this;
183 }
184
185 bool operator==(const DataElement &de) const
186 {
187 bool b = TagField == de.TagField
188 && ValueLengthField == de.ValueLengthField
189 && VRField == de.VRField;
190 if( !ValueField && !de.ValueField )
191 {
192 return b;
193 }
194 if( ValueField && de.ValueField )
195 {
196 return b && (*ValueField == *de.ValueField);
197 }
198 // ValueField != de.ValueField
199 return false;
200 }
201
202 // The following fonctionalities are dependant on:
203 // # The Transfer Syntax: Explicit or Implicit
204 // # The Byte encoding: Little Endian / Big Endian
205
206 /*
207 * The following was inspired by a C++ idiom: Curiously Recurring Template Pattern
208 * Ref: http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern
209 * The typename TDE is typically a derived class *without* any data
210 * while TSwap is a simple template parameter to achieve byteswapping (and allow factorization of
211 * highly identical code)
212 */
213 template <typename TDE>
214 VL GetLength() const {
215 return static_cast<const TDE*>(this)->GetLength();
216 }
217
218 template <typename TDE, typename TSwap>
219 std::istream &Read(std::istream &is) {
220 return static_cast<TDE*>(this)->template Read<TSwap>(is);
221 }
222
223 template <typename TDE, typename TSwap>
224 std::istream &ReadOrSkip(std::istream &is, std::set<Tag> const &skiptags) {
225 (void)skiptags;
226 return static_cast<TDE*>(this)->template Read<TSwap>(is);
227 }
228
229 template <typename TDE, typename TSwap>
230 std::istream &ReadPreValue(std::istream &is, std::set<Tag> const &skiptags) {
231 (void)skiptags;
232 return static_cast<TDE*>(this)->template ReadPreValue<TSwap>(is);
233 }
234 template <typename TDE, typename TSwap>
235 std::istream &ReadValue(std::istream &is, std::set<Tag> const &skiptags) {
236 (void)skiptags;
237 return static_cast<TDE*>(this)->template ReadValue<TSwap>(is);
238 }
239
240 template <typename TDE, typename TSwap>
241 std::istream &ReadWithLength(std::istream &is, VL &length) {
242 return static_cast<TDE*>(this)->template ReadWithLength<TSwap>(is,length);
243 }
244
245 template <typename TDE, typename TSwap>
246 const std::ostream &Write(std::ostream &os) const {
247 return static_cast<const TDE*>(this)->template Write<TSwap>(os);
248 }
249
250 protected:
251 Tag TagField;
252 // This is the value read from the file, might be different from the length of Value Field
253 VL ValueLengthField; // Can be 0xFFFFFFFF
254
255 // Value Representation
256 VR VRField;
257 typedef SmartPointer<Value> ValuePtr;
258 ValuePtr ValueField;
259 };
260 //-----------------------------------------------------------------------------
261 inline std::ostream& operator<<(std::ostream &os, const DataElement &val)
262 {
263 os << val.TagField;
264 os << "\t" << val.VRField;
265 os << "\t" << val.ValueLengthField;
266 if( val.ValueField )
267 {
268 val.ValueField->Print( os << "\t" );
269 }
270 return os;
271 }
272
273 inline bool operator!=(const DataElement& lhs, const DataElement& rhs)
274 {
275 return ! ( lhs == rhs );
276 }
277
278 } // end namespace gdcm
279
280 #endif //GDCMDATAELEMENT_H