gdcmDict.cxx

// gdcmDict.cxx
//-----------------------------------------------------------------------------
#include "gdcmDict.h"
#include "gdcmUtil.h"

#include <fstream>
#include <iostream>
#include <iomanip>

#ifdef GDCM_NO_ANSI_STRING_STREAM
#  include <strstream>
#  define  ostringstream ostrstream
# else
#  include <sstream>
#endif

//-----------------------------------------------------------------------------
// Constructor / Destructor
gdcmDict::gdcmDict(std::string & FileName) {
   guint16 group, element;
   char buff[1024];
   TagName vr;
   TagName fourth;
   TagName name;

   std::ifstream from(FileName.c_str());
   dbg.Error(!from, "gdcmDict::gdcmDict: can't open dictionary",
                    FileName.c_str());

   while (!from.eof()) {
      from >> std::hex >> group >> element;
      eatwhite(from);
      from.getline(buff, 256, ' ');
      vr = buff;
      eatwhite(from);
      from.getline(buff, 256, ' ');
      fourth = buff;
      from.getline(buff, 256, '\n');
      name = buff;

      gdcmDictEntry * newEntry = new gdcmDictEntry(group, element,
                                                   vr, fourth, name);
      AddNewEntry(newEntry);
   }
   from.close();

   filename=FileName;
}

gdcmDict::~gdcmDict() {
   for (TagKeyHT::iterator tag = KeyHt.begin(); tag != KeyHt.end(); ++tag) {
      gdcmDictEntry* EntryToDelete = tag->second;
      if ( EntryToDelete )
         delete EntryToDelete;
   }

   // Since AddNewEntry adds symetrical in both KeyHt and NameHT we can
   // assume all the pointed gdcmDictEntries are already cleaned-up when
   // we cleaned KeyHt.
   KeyHt.clear();
   NameHt.clear();
}

//-----------------------------------------------------------------------------
// Print
void gdcmDict::Print(std::ostream &os) {
   os<<"Dict file name : "<<filename<<std::endl;
   PrintByKey(os);
}

void gdcmDict::PrintByKey(std::ostream &os) {
   std::ostringstream s;

   for (TagKeyHT::iterator tag = KeyHt.begin(); tag != KeyHt.end(); ++tag){
      s << "Entry : ";
      s << "(" << std::hex << std::setw(4) << tag->second->GetGroup() << ',';
      s << std::hex << std::setw(4) << tag->second->GetElement() << ") = " << std::dec;
      s << tag->second->GetVR() << ", ";
      s << tag->second->GetFourth() << ", ";
      s << tag->second->GetName() << "."  << std::endl;
   }
   os << s.str();
}

void gdcmDict::PrintByName(std::ostream& os) {
   std::ostringstream s;

   for (TagNameHT::iterator tag = NameHt.begin(); tag != NameHt.end(); ++tag){
      s << "Entry : ";
      s << tag->second->GetName() << ",";
      s << tag->second->GetVR() << ", ";
      s << tag->second->GetFourth() << ", ";
      s << "(" << std::hex << std::setw(4) << tag->second->GetGroup() << ',';
      s << std::hex << std::setw(4) << tag->second->GetElement() << ") = ";
      s << std::dec << std::endl;
   }
   os << s.str();
}

//-----------------------------------------------------------------------------
// Public
bool gdcmDict::AddNewEntry(gdcmDictEntry *NewEntry) 
{
   TagKey key;
   key = NewEntry->GetKey();
        
   if(KeyHt.count(key) == 1)
   {
      dbg.Verbose(1, "gdcmDict::AddNewEntry already present", key.c_str());
      return(false);
   } 
   else 
   {
      KeyHt[NewEntry->GetKey()] = NewEntry;
      NameHt[NewEntry->GetName()] = NewEntry;
      return(true);
   }
}

bool gdcmDict::ReplaceEntry(gdcmDictEntry *NewEntry) {
   if ( RemoveEntry(NewEntry->gdcmDictEntry::GetKey()) ) {
       KeyHt[NewEntry->GetKey()] = NewEntry;
       NameHt[NewEntry->GetName()] = NewEntry;
       return (true);
   } 
   return (false);
}

bool gdcmDict::RemoveEntry(TagKey key) 
{
   if(KeyHt.count(key) == 1) 
   {
      gdcmDictEntry* EntryToDelete = KeyHt.find(key)->second;

      if ( EntryToDelete )
      {
         NameHt.erase(EntryToDelete->GetName());
         delete EntryToDelete;
      }

      KeyHt.erase(key);
      return (true);
   } 
   else 
   {
      dbg.Verbose(1, "gdcmDict::RemoveEntry unfound entry", key.c_str());
      return (false);
  }
}

bool gdcmDict::RemoveEntry (guint16 group, guint16 element) {
        return( RemoveEntry(gdcmDictEntry::TranslateToKey(group, element)) );
}

gdcmDictEntry *gdcmDict::GetDictEntryByName(TagName name) {
   if ( ! NameHt.count(name))
      return NULL; 
   return NameHt.find(name)->second;
}

gdcmDictEntry *gdcmDict::GetDictEntryByNumber(guint16 group, guint16 element) {
   TagKey key = gdcmDictEntry::TranslateToKey(group, element);
   if ( ! KeyHt.count(key))
      return NULL; 
   return KeyHt.find(key)->second;
}

std::list<std::string> *gdcmDict::GetDictEntryNames(void) 
{
   std::list<std::string> *Result = new std::list<std::string>;
   for (TagKeyHT::iterator tag = KeyHt.begin(); tag != KeyHt.end(); ++tag)
   {
      Result->push_back( tag->second->GetName() );
   }
   return Result;
}

std::map<std::string, std::list<std::string> > *gdcmDict::GetDictEntryNamesByCategory(void) 
{
   std::map<std::string, std::list<std::string> > *Result = new std::map<std::string, std::list<std::string> >;

   for (TagKeyHT::iterator tag = KeyHt.begin(); tag != KeyHt.end(); ++tag)
   {
      (*Result)[tag->second->GetFourth()].push_back(tag->second->GetName());
   }
   return Result;
}

//-----------------------------------------------------------------------------
// Protected

//-----------------------------------------------------------------------------
// Private

//-----------------------------------------------------------------------------

---