src/gdcmDocEntrySet.cxx

   1 /*=========================================================================
   2
   3   Program:   gdcm
   4   Module:    $RCSfile: gdcmDocEntrySet.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2004/10/27 22:31:12 $
   7   Version:   $Revision: 1.25 $
   8
   9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
  10   l'Image). All rights reserved. See Doc/License.txt or
  11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
  12
  13      This software is distributed WITHOUT ANY WARRANTY; without even
  14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15      PURPOSE.  See the above copyright notices for more information.
  16
  17 =========================================================================*/
  18 #include "gdcmDocEntrySet.h"
  19
  20 #include "gdcmDebug.h"
  21 #include "gdcmCommon.h"
  22 #include "gdcmGlobal.h"
  23 #include "gdcmException.h"
  24 #include "gdcmDocEntry.h"
  25 #include "gdcmSeqEntry.h"
  26 #include "gdcmValEntry.h"
  27 #include "gdcmBinEntry.h"
  28
  29 namespace gdcm
  30 {
  31
  32 //-----------------------------------------------------------------------------
  33 // Public
  34
  35 /**
  36  * \brief   Build a new Val Entry from all the low level arguments.
  37  *          Check for existence of dictionary entry, and build
  38  *          a default one when absent.
  39  * @param   group group   number of the underlying DictEntry
  40  * @param   elem  element number of the underlying DictEntry
  41  */
  42 ValEntry *DocEntrySet::NewValEntryByNumber(uint16_t group,
  43                                            uint16_t elem)
  44 {
  45    // Find out if the tag we encountered is in the dictionaries:
  46    DictEntry *dictEntry = GetDictEntryByNumber(group, elem);
  47    if (!dictEntry)
  48    {
  49       dictEntry = NewVirtualDictEntry(group, elem);
  50    }
  51
  52    ValEntry *newEntry = new ValEntry(dictEntry);
  53    if (!newEntry)
  54    {
  55       dbg.Verbose(1, "Document::NewValEntryByNumber",
  56                   "failed to allocate ValEntry");
  57       return 0;
  58    }
  59    return newEntry;
  60 }
  61
  62
  63 /**
  64  * \brief   Build a new Bin Entry from all the low level arguments.
  65  *          Check for existence of dictionary entry, and build
  66  *          a default one when absent.
  67  * @param   group group   number of the underlying DictEntry
  68  * @param   elem  element number of the underlying DictEntry
  69  */
  70 BinEntry *DocEntrySet::NewBinEntryByNumber(uint16_t group,
  71                                            uint16_t elem)
  72 {
  73    // Find out if the tag we encountered is in the dictionaries:
  74    DictEntry *dictEntry = GetDictEntryByNumber(group, elem);
  75    if (!dictEntry)
  76    {
  77       dictEntry = NewVirtualDictEntry(group, elem);
  78    }
  79
  80    BinEntry *newEntry = new BinEntry(dictEntry);
  81    if (!newEntry)
  82    {
  83       dbg.Verbose(1, "Document::NewBinEntryByNumber",
  84                   "failed to allocate BinEntry");
  85       return 0;
  86    }
  87    return newEntry;
  88 }
  89
  90 /**
  91  * \brief   Build a new Seq Entry from all the low level arguments.
  92  *          Check for existence of dictionary entry, and build
  93  *          a default one when absent.
  94  * @param   Group group   number of the underlying DictEntry
  95  * @param   Elem  element number of the underlying DictEntry
  96  */
  97 SeqEntry* DocEntrySet::NewSeqEntryByNumber(uint16_t Group,
  98                                                    uint16_t Elem)
  99 {
 100    // Find out if the tag we encountered is in the dictionaries:
 101    DictEntry* DictEntry = GetDictEntryByNumber( Group, Elem );
 102    if ( ! DictEntry )
 103    {
 104       DictEntry = NewVirtualDictEntry(Group, Elem);
 105    }
 106
 107    SeqEntry *NewEntry = new SeqEntry( DictEntry );
 108    if ( !NewEntry )
 109    {
 110       dbg.Verbose(1, "Document::NewSeqEntryByNumber",
 111                   "failed to allocate SeqEntry");
 112       return 0;
 113    }
 114    return NewEntry;
 115 }
 116
 117 //-----------------------------------------------------------------------------
 118 // Protected
 119
 120 /**
 121  * \brief   Gets a Dicom Element inside a SQ Item Entry, by name
 122  * @return
 123  */
 124  DocEntry *DocEntrySet::GetDocEntryByName(std::string const & name)
 125  {
 126    Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
 127    DictEntry *dictEntry = pubDict->GetDictEntryByName(name);
 128    if( !dictEntry )
 129    {
 130       return 0;
 131    }
 132
 133    return GetDocEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement());
 134 }
 135
 136
 137 /**
 138  * \brief   Get the value of a Dicom Element inside a SQ Item Entry, by name
 139  * @param   name : name of the searched element.
 140  * @return
 141  */
 142
 143 std::string DocEntrySet::GetEntryByName(TagName const & name)
 144 {
 145    Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
 146    DictEntry *dictEntry = pubDict->GetDictEntryByName(name);
 147
 148    if( !dictEntry )
 149    {
 150       return GDCM_UNFOUND;
 151    }
 152
 153    return GetEntryByNumber(dictEntry->GetGroup(), dictEntry->GetElement());
 154 }
 155
 156
 157 /**
 158  * \brief   Request a new virtual dict entry to the dict set
 159  * @param   group     group  number of the underlying DictEntry
 160  * @param   element  element number of the underlying DictEntry
 161  * @param   vr     VR of the underlying DictEntry
 162  * @param   fourth owner group
 163  * @param   name   english name
 164  */
 165 DictEntry* DocEntrySet::NewVirtualDictEntry(uint16_t group,
 166                                                     uint16_t element,
 167                                                     std::string const & vr,
 168                                                     std::string const & fourth,
 169                                                     std::string const & name)
 170 {
 171    return Global::GetDicts()->NewVirtualDictEntry(group,element,vr,fourth,name);
 172 }
 173
 174 /** \brief
 175  * Creates a new DocEntry (without any 'value' ...)
 176  * @param   group     group  number of the underlying DictEntry
 177  * @param   elem  elem number of the underlying DictEntry
 178  */
 179 DocEntry* DocEntrySet::NewDocEntryByNumber(uint16_t group,
 180                                            uint16_t elem)
 181 {
 182    // Find out if the tag we encountered is in the dictionaries:
 183    Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
 184    DictEntry *dictEntry = pubDict->GetDictEntryByNumber(group, elem);
 185    if (!dictEntry)
 186    {
 187       dictEntry = NewVirtualDictEntry(group, elem);
 188    }
 189
 190    DocEntry *newEntry = new DocEntry(dictEntry);
 191    if (!newEntry)
 192    {
 193       dbg.Verbose(1, "SQItem::NewDocEntryByNumber",
 194                   "failed to allocate DocEntry");
 195       return 0;
 196    }
 197    return newEntry;
 198 }
 199
 200
 201 /** \brief
 202  * Creates a new DocEntry (without any 'value' ...)
 203  * @param   group     group  number of the underlying DictEntry
 204  * @param   elem  elem number of the underlying DictEntry
 205  * @param   VR   V(alue) R(epresentation) of the Entry -if private Entry-
 206
 207  */
 208 DocEntry* DocEntrySet::NewDocEntryByNumber(uint16_t group, uint16_t elem,
 209                                            TagName const & vr)
 210 {
 211    // Find out if the tag we encountered is in the dictionaries:
 212    Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
 213    DictEntry *dictEntry = pubDict->GetDictEntryByNumber(group, elem);
 214    if (!dictEntry)
 215    {
 216       dictEntry = NewVirtualDictEntry(group, elem, vr);
 217    }
 218
 219    DocEntry *newEntry = new DocEntry(dictEntry);
 220    if (!newEntry)
 221    {
 222       dbg.Verbose(1, "SQItem::NewDocEntryByNumber",
 223                   "failed to allocate DocEntry");
 224       return 0;
 225    }
 226    return newEntry;
 227 }
 228 /* \brief
 229  * Probabely move, as is, to DocEntrySet, as a non virtual method
 230  * and remove Document::NewDocEntryByName
 231  */
 232 DocEntry *DocEntrySet::NewDocEntryByName(TagName const & name)
 233 {
 234   Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
 235   DictEntry *newTag = pubDict->GetDictEntryByName(name);
 236    if (!newTag)
 237    {
 238       newTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "unkn", name);
 239    }
 240
 241    DocEntry* newEntry = new DocEntry(newTag);
 242    if (!newEntry)
 243    {
 244       dbg.Verbose(1, "SQItem::ObtainDocEntryByName",
 245                   "failed to allocate DocEntry");
 246       return 0;
 247    }
 248
 249    return newEntry;
 250 }
 251
 252
 253 /**
 254  * \brief   Searches both the public and the shadow dictionary (when they
 255  *          exist) for the presence of the DictEntry with given name.
 256  *          The public dictionary has precedence on the shadow one.
 257  * @param   name Name of the searched DictEntry
 258  * @return  Corresponding DictEntry when it exists, NULL otherwise.
 259  */
 260 DictEntry *DocEntrySet::GetDictEntryByName(TagName const & name)
 261 {
 262    DictEntry *found = 0;
 263    Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
 264    if (!pubDict)
 265    {
 266       dbg.Verbose(0, "Document::GetDictEntry",
 267                      "we SHOULD have a default dictionary");
 268    }
 269    else
 270    {
 271       found = pubDict->GetDictEntryByName(name);
 272    }
 273    return found;
 274 }
 275
 276 /**
 277  * \brief   Searches both the public and the shadow dictionary (when they
 278  *          exist) for the presence of the DictEntry with given
 279  *          group and element. The public dictionary has precedence on the
 280  *          shadow one.
 281  * @param   group   group number of the searched DictEntry
 282  * @param   element element number of the searched DictEntry
 283  * @return  Corresponding DictEntry when it exists, NULL otherwise.
 284  */
 285 DictEntry *DocEntrySet::GetDictEntryByNumber(uint16_t group,
 286                                              uint16_t element)
 287 {
 288    DictEntry *found = 0;
 289    Dict *pubDict = Global::GetDicts()->GetDefaultPubDict();
 290    if (!pubDict)
 291    {
 292       dbg.Verbose(0, "Document::GetDictEntry",
 293                      "we SHOULD have a default dictionary");
 294    }
 295    else
 296    {
 297       found = pubDict->GetDictEntryByNumber(group, element);
 298    }
 299    return found;
 300 }
 301
 302
 303 //-----------------------------------------------------------------------------
 304 // Private
 305
 306 } // end namespace gdcm
 307
 308 //-----------------------------------------------------------------------------