gdcmDictSet.cxx

// gdcmDictEntry
//-----------------------------------------------------------------------------
#include "gdcmDictSet.h"
#include "gdcmUtil.h"
#include <fstream>
#include <stdlib.h>  // For getenv

#define PUB_DICT_NAME     "DicomV3Dict"
#ifndef PUB_DICT_PATH
#  define PUB_DICT_PATH     "../Dicts/"
#endif
#define PUB_DICT_FILENAME "dicomV3.dic"

//-----------------------------------------------------------------------------
// Constructor / Destructor
gdcmDictSet::gdcmDictSet(void) 
{
   DictPath = BuildDictPath();
   std::string PubDictFile = DictPath + PUB_DICT_FILENAME;
   Dicts[PUB_DICT_NAME] = new gdcmDict(PubDictFile);
}

gdcmDictSet::~gdcmDictSet() 
{
   // Remove dictionnaries
   for (DictSetHT::iterator tag = Dicts.begin(); tag != Dicts.end(); ++tag) 
   {
      gdcmDict *EntryToDelete = tag->second;
      if ( EntryToDelete )
         delete EntryToDelete;
      tag->second=NULL;
   }
   Dicts.clear();

   // Remove virtual dictionnary entries
   std::map<std::string,gdcmDictEntry *>::iterator it;
   for(it=virtualEntry.begin(); it!=virtualEntry.end(); ++it)
   {
      gdcmDictEntry *Entry = it->second;
      if ( Entry )
         delete Entry;
      it->second=NULL;
   }
}

//-----------------------------------------------------------------------------
// Print
void gdcmDictSet::Print(std::ostream& os) 
{
   for (DictSetHT::iterator dict = Dicts.begin(); dict != Dicts.end(); ++dict)
   {
      os << "Printing dictionary " << dict->first << std::endl;
      dict->second->Print(os);
   }
}

//-----------------------------------------------------------------------------
// Public
std::list<std::string> *gdcmDictSet::GetPubDictEntryNames(void) 
{
   return(GetDefaultPubDict()->GetDictEntryNames());
}

std::map<std::string, std::list<std::string> > *gdcmDictSet::GetPubDictEntryNamesByCategory(void) 
{
   return(GetDefaultPubDict()->GetDictEntryNamesByCategory());
}

gdcmDict *gdcmDictSet::LoadDictFromFile(std::string FileName, DictKey Name) 
{
   gdcmDict *NewDict = new gdcmDict(FileName);
   AppendDict(NewDict,Name);
   return(NewDict);
}

gdcmDict *gdcmDictSet::GetDict(DictKey DictName) 
{
   DictSetHT::iterator dict = Dicts.find(DictName);
   if(dict!=Dicts.end())
      return dict->second;
   return NULL;
}

gdcmDict *gdcmDictSet::GetDefaultPubDict() 
{
   return GetDict(PUB_DICT_NAME);
}

gdcmDictEntry *gdcmDictSet::NewVirtualDictEntry(guint16 group, guint16 element,
                                                std::string vr,std::string fourth,
                                                std::string name)
{
   gdcmDictEntry *entry;
   std::string tag=gdcmDictEntry::TranslateToKey(group,element)+"#"+vr+"#"+fourth+"#"+name;
   std::map<std::string,gdcmDictEntry *>::iterator it;
   
   it=virtualEntry.find(tag);
   if(it!=virtualEntry.end())
   {
      entry=it->second;
   }
   else
   {
      entry=new gdcmDictEntry(group,element,vr,fourth,name);
      virtualEntry[tag]=entry;
   }
   return(entry);
}

std::string gdcmDictSet::BuildDictPath(void) 
{
   std::string ResultPath;
   const char *EnvPath = (char*)0;
   EnvPath = getenv("GDCM_DICT_PATH");
   if (EnvPath && (strlen(EnvPath) != 0)) 
   {
      ResultPath = EnvPath;
      if (ResultPath[ResultPath.length() -1] != '/' )
         ResultPath += '/';
      dbg.Verbose(1, "gdcmDictSet::BuildDictPath:",
                     "Dictionary path set from environnement");
   } 
   else
      ResultPath = PUB_DICT_PATH;
   return ResultPath;
}

//-----------------------------------------------------------------------------
// Protected
bool gdcmDictSet::AppendDict(gdcmDict *NewDict,DictKey Name)
{
   Dicts[Name] = NewDict;
   return(true);
}

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

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

---