GDCM  2.2.0
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;
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 
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:
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
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

Generated on Wed Jun 13 2012 20:40:37 for GDCM by doxygen 1.8.1
SourceForge.net Logo