gdcmHeaderEntry.h

// gdcmHeaderEntry.h
//-----------------------------------------------------------------------------
#ifndef GDCMHeaderEntry_H
#define GDCMHeaderEntry_H

#include <iostream>
#include <stdio.h>

#include "gdcmDictEntry.h"
class gdcmHeader;

//-----------------------------------------------------------------------------
/*
 * The dicom header of a Dicom file contains a set of such entries
 * (when successfuly parsed against a given Dicom dictionary)
 */
class GDCM_EXPORT gdcmHeaderEntry {
public:
   gdcmHeaderEntry(gdcmDictEntry*);
   
   inline guint16      GetGroup(void)     { return entry->GetGroup();  };
   inline guint16      GetElement(void)   { return entry->GetElement();};
   inline std::string  GetKey(void)       { return entry->GetKey();    };
   inline std::string  GetName(void)      { return entry->GetName();   };
   inline std::string  GetVR(void)        { return entry->GetVR();     };
   inline std::string  GetValue(void)     { return value;              };

   inline void *       GetVoidArea(void)  { return voidArea;           };
   inline size_t       GetOffset(void)    { return Offset;             };   
   inline guint32      GetLength(void)    { return UsableLength;       };   

   inline void         SetVR(std::string v)      { entry->SetVR(v);          };    
   inline void         SetLength(guint32 l)      { ReadLength=UsableLength=l;};
      
   // The following 3 members, for internal use only ! 
   inline void         SetReadLength(guint32 l)  { ReadLength   = l; };         
   inline void         SetUsableLength(guint32 l){ UsableLength = l; };         
   inline guint32      GetReadLength(void)       { return ReadLength;};
        
   inline void         SetValue(std::string val) { value = val;      };
   inline void         SetVoidArea(void * area)  { voidArea = area;  };
   
   inline void gdcmHeaderEntry::SetOffset(size_t of) { Offset = of; };

   inline void gdcmHeaderEntry::SetImplicitVR(void) { ImplicitVR = true; };
 
   inline bool  gdcmHeaderEntry::IsImplicitVR(void) { return ImplicitVR; };

   inline bool   gdcmHeaderEntry::IsVRUnknown(void) { return entry->IsVRUnknown(); };

   inline void gdcmHeaderEntry::SetDictEntry(gdcmDictEntry *NewEntry) { 
      entry = NewEntry;
   };

   gdcmDictEntry * gdcmHeaderEntry::GetDictEntry(void) { return entry; }; 

   void SetPrintLevel(int level) { printLevel = level; };
   void Print (std::ostream & os = std::cout); 

private:
   // FIXME: In fact we should be more specific and use :
   // friend gdcmHeaderEntry * gdcmHeader::ReadNextElement(void);
   friend class gdcmHeader;

// Variables
   gdcmDictEntry *entry;
   guint32 UsableLength;  // Updated from ReadLength, by FixFoungLentgh()
                          // for fixing a bug in the header or helping
                          // the parser going on 
                          
   guint32 ReadLength;    // Length actually read on disk
                          // (before FixFoundLength)
                          // ReadLength will be updated only when
                          // FixFoundLength actually fixes a bug in the header,
                          // not when it performs a trick to help the Parser
                          // going on.
                          // *for internal* use only
        
   bool ImplicitVR;       // Even when reading explicit vr files, some
                          // elements happen to be implicit. Flag them here
                          // since we can't use the entry->vr without breaking
                          // the underlying dictionary.
                          

   std::string  value;
   void *voidArea;   // unsecure memory area to hold 'non string' values 
                     // (ie : Lookup Tables, overlays)
   size_t Offset;    // Offset from the begining of file for direct user access
   int printLevel;
};

//-----------------------------------------------------------------------------
#endif

---