gdcmStrictScanner.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 GDCMSTRICTSCANNER_H
#define GDCMSTRICTSCANNER_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 StrictScanner : public Subject
{
  friend std::ostream& operator<<(std::ostream &_os, const StrictScanner &s);
public:
  StrictScanner():Values(),Filenames(),Mappings() {}
  ~StrictScanner() override;
 
  typedef std::map<Tag, const char*> TagToValue;
  //typedef std::map<Tag, ConstCharWrapper> TagToValue; //StringMap;
  //typedef TagToStringMap TagToValue;
  typedef TagToValue::value_type TagToValueValueType;
 
  void AddTag( Tag const & t );
  void ClearTags();
 
  // Work in progress do not use:
  void AddPrivateTag( PrivateTag const & t );
 
  void 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 ) 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 GetValues(Tag const &t) const;
 
  Directory::FilenamesType GetOrderedValues(Tag const &t) 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 *,TagToValue, ltstr> MappingType;
  typedef MappingType::const_iterator ConstIterator;
  ConstIterator Begin() const { return Mappings.begin(); }
  ConstIterator End() const { return Mappings.end(); }
 
  MappingType const & GetMappings() const { return Mappings; }
 
  TagToValue const & GetMapping(const char *filename) const;
 
  const char *GetFilenameFromTagToValue(Tag const &t, const char *valueref) const;
 
  Directory::FilenamesType GetAllFilenamesFromTagToValue(Tag const &t, const char *valueref) const;
 
  // by a call to GetMapping()
  TagToValue const & GetMappingFromTagToValue(Tag const &t, const char *value) const;
 
  const char* GetValue(const char *filename, Tag const &t) const;
 
  static SmartPointer<StrictScanner> New() { return new StrictScanner; }
 
protected:
  void ProcessPublicTag(StringFilter &sf, const char *filename);
private:
  // struct to store all uniq tags in ascending order:
  typedef std::set< Tag > TagsType;
  typedef std::set< PrivateTag > PrivateTagsType;
  std::set< Tag > Tags;
  std::set< PrivateTag > PrivateTags;
  std::set< Tag > SkipTags;
  ValuesType Values;
  Directory::FilenamesType Filenames;
 
  // Main struct that will hold all mapping:
  MappingType Mappings;
 
  double Progress;
};
//-----------------------------------------------------------------------------
inline std::ostream& operator<<(std::ostream &os, const StrictScanner &s)
{
  s.Print( os );
  return os;
}
 
} // end namespace gdcm
 
#endif //GDCMSTRICTSCANNER_H