mlDICOMCachedIOTagCacheMap.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
#pragma once
 
#include "MLDICOMCachedIOSystem.h"
#include <mlTypeDefs.h>
 
#include <ThirdPartyWarningsDisable.h>
#include <list>
#include <set>
#include <ThirdPartyWarningsRestore.h>
 
#include <mlConstantString.h>
#include <mlSubImage.h>
#include "mlDICOMCachedIOFileHandle.h"
 
#include <DCMTree_Tag.h>
 
#include <ThirdPartyWarningsDisable.h>
#include <boost/unordered_map.hpp>
#include <ThirdPartyWarningsRestore.h>
 
namespace ML_NAMESPACE {
  class IntField;
  class DicomMessageCollector;
};
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
class MLDICOMCachedIO_EXPORT MLDICOMCachedIOTagCacheMap {
 
public:
 
  MLDICOMCachedIOTagCacheMap();
 
  ~MLDICOMCachedIOTagCacheMap();
 
  // -------------- Management of tags:
  
  MLint getMaxNumBytes() const;
  
  void setMaxNumMegaBytes(MLint maxNumMegaBytes);
  
  MLint getMaxNumMegaBytes() const;
  
  ml::IntField& getMaxNumMegaBytesFld();
 
  MLint getTotalNumberOfBytes() const;
 
  MLint flush(const MLint maxBytes, const bool flushAll=false);
 
  MLint flush();
  
  MLint getNumFlushedBytes() const;
  
  void resetNumFlushedBytes();
 
  void removeAssociatedEntries(const ML_NAMESPACE::DICOMCachedIOFileHandle &fileHandle);
  
  void clear();
 
  //----------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------
  struct TagKey
  {
    inline TagKey(): _id(0){}
 
    inline TagKey(MLuint32 id, const ML_NAMESPACE::ConstantString& fileName): _id(id), _fileName(fileName){}
 
    inline bool operator==(const TagKey& other) const {
      return (_id == other._id) && (_fileName == other._fileName);
    }
 
    MLuint32 _id;
 
    ML_NAMESPACE::ConstantString _fileName;
    
    std::list<TagKey>::iterator _recentlyCachedIt;
  };
 
  struct TagHashFunction
  {
    inline size_t operator()(TagKey const& key) const
    {
      size_t hash = hash_value(key._fileName);
      boost::hash_combine(hash, key._id);
      return hash;
    }
  };
 
 
  typedef boost::unordered_map< TagKey, DCMTree::Const_TagPtr, TagHashFunction > CacheMapType;
 
  DCMTree::Const_TagPtr getCachedDCMTag(const ML_NAMESPACE::DICOMCachedIOFileHandle &fileHandle,
                                        DCMTree::RawTagId rawTagId) const;
 
  void insertTag(MLDICOMCachedIOTagCacheMap::TagKey &key, 
                 DCMTree::Const_TagPtr tagPtr, 
                 const MLint tagValSize);
 
  DCMTree::Const_TagPtr loadDCMTag(const ML_NAMESPACE::ConstantString  &fileHandle,
                                   DCMTree::RawTagId                   rawTagId,
                                   MLint                               maxTagValueSizeToCache,
                                   bool                                *treeLoadFailed,
                                   bool                                *cacheMiss,
                                   ML_NAMESPACE::DicomMessageCollector &dcmMsgCollector);
  
  void prefetchDCMTags(const ML_NAMESPACE::ConstantString  &fileHandle,
                       const std::set<MLuint32>            &tagIds,
                       MLint                               maxTagValueSizeToCache,
                       bool                                *treeLoadFailed,
                       ML_NAMESPACE::DicomMessageCollector &dcmMsgCollector);
  
protected:
 
  friend class MLDICOMCachedIOTagCache;
  
  CacheMapType           _cache;
 
  std::list<TagKey>      _recentlyCached;
 
  MLint                  _totalNumBytes;
 
  MLint                  _numFlushedBytes;
  
  ml::IntField           *_limitInMegaBytesFld;
};