gdcmScanner2.h

Go to the documentation of this file.

/*=========================================================================
 
  Program: GDCM (Grassroots DICOM). A DICOM library
 
  Copyright (c) 2006-2011 Mathieu Malaterre
  All rights reserved.
  See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef GDCMSCANNER2_H
#define GDCMSCANNER2_H
 
#include "gdcmDirectory.h"
#include "gdcmSubject.h"
#include "gdcmTag.h"
#include "gdcmPrivateTag.h"
#include "gdcmSmartPointer.h"
 
#include <map>
#include <set>
#include <string>
 
#include <string.h> // strcmp
 
namespace gdcm
{
class StringFilter;
 
class GDCM_EXPORT Scanner2 : public Subject
{
  friend std::ostream& operator<<(std::ostream &_os, const Scanner2 &s);
public:
  Scanner2():Values(),Filenames(),PublicMappings(),PrivateMappings(),Progress(0.0) {}
  ~Scanner2() override;
 
  typedef std::map<Tag, const char*> PublicTagToValue;
  typedef PublicTagToValue::value_type PublicTagToValueValueType;
 
  typedef std::map<PrivateTag, const char*> PrivateTagToValue;
  typedef PrivateTagToValue::value_type PrivateTagToValueValueType;
 
  bool AddPublicTag( Tag const & t );
  void ClearPublicTags();
 
  // Work in progress do not use:
  bool AddPrivateTag( PrivateTag const & pt );
  void ClearPrivateTags();
 
  bool AddSkipTag( Tag const & t );
  void ClearSkipTags();
 
  bool Scan( Directory::FilenamesType const & filenames );
 
  Directory::FilenamesType const &GetFilenames() const { return Filenames; }
 
  void Print( std::ostream & os ) const override;
 
  void PrintTable( std::ostream & os, bool header = false ) const;
 
  bool IsKey( const char * filename ) const;
 
  Directory::FilenamesType GetKeys() const;
 
  // struct to store all the values found:
  typedef std::set< std::string > ValuesType;
 
  ValuesType const & GetValues() const { return Values; }
 
  ValuesType GetPublicValues(Tag const &t) const;
 
  ValuesType GetPrivateValues(PrivateTag const &pt) const;
 
  Directory::FilenamesType GetPublicOrderedValues(Tag const &t) const;
 
  Directory::FilenamesType GetPrivateOrderedValues(PrivateTag const &pt) const;
 
  /* ltstr is CRITICAL, otherwise pointers value are used to do the key comparison */
  struct ltstr
    {
    bool operator()(const char* s1, const char* s2) const
      {
      assert( s1 && s2 );
      return strcmp(s1, s2) < 0;
      }
    };
  typedef std::map<const char *,PublicTagToValue, ltstr> PublicMappingType;
  typedef PublicMappingType::const_iterator PublicConstIterator;
  PublicConstIterator Begin() const { return PublicMappings.begin(); }
  PublicConstIterator End() const { return PublicMappings.end(); }
 
  typedef std::map<const char *,PrivateTagToValue, ltstr> PrivateMappingType;
  typedef PrivateMappingType::const_iterator PrivateConstIterator;
  PrivateConstIterator PrivateBegin() const { return PrivateMappings.begin(); }
  PrivateConstIterator PrivateEnd() const { return PrivateMappings.end(); }
 
  PublicMappingType const & GetPublicMappings() const { return PublicMappings; }
  PrivateMappingType const & GetPrivateMappings() const { return PrivateMappings; }
 
  PublicTagToValue const & GetPublicMapping(const char *filename) const;
  PrivateTagToValue const & GetPrivateMapping(const char *filename) const;
 
  const char *GetFilenameFromPublicTagToValue(Tag const &t, const char *valueref) const;
  const char *GetFilenameFromPrivateTagToValue(PrivateTag const &pt, const char *valueref) const;
 
  Directory::FilenamesType GetAllFilenamesFromPublicTagToValue(Tag const &t, const char *valueref) const;
  Directory::FilenamesType GetAllFilenamesFromPrivateTagToValue(PrivateTag const &pt, const char *valueref) const;
 
  // by a call to GetMapping()
  PublicTagToValue const & GetMappingFromPublicTagToValue(Tag const &t, const char *value) const;
  PrivateTagToValue const & GetMappingFromPrivateTagToValue(PrivateTag const &pt, const char *value) const;
 
  const char* GetPublicValue(const char *filename, Tag const &t) const;
  const char* GetPrivateValue(const char *filename, PrivateTag const &t) const;
 
  static SmartPointer<Scanner2> New() { return new Scanner2; }
 
protected:
  void ProcessPublicTag(StringFilter &sf, const char *filename);
  void ProcessPrivateTag(StringFilter &sf, const char *filename);
private:
  // struct to store all uniq tags in ascending order:
  typedef std::set< Tag > PublicTagsType;
  typedef std::set< PrivateTag > PrivateTagsType;
  std::set< Tag > PublicTags; // Public and Private Creator
  std::set< PrivateTag > PrivateTags; // Only Private (no Private Creator)
  std::set< Tag > SkipTags;
  ValuesType Values;
  Directory::FilenamesType Filenames;
 
  // Main struct that will hold all public mapping:
  PublicMappingType PublicMappings;
  // Main struct that will hold all private mapping:
  PrivateMappingType PrivateMappings;
 
  double Progress;
};
//-----------------------------------------------------------------------------
inline std::ostream& operator<<(std::ostream &os, const Scanner2 &s)
{
  s.Print( os );
  return os;
}
 
} // end namespace gdcm
 
#endif //GDCMSCANNER2_H