vtkCacheManager.h

Go to the documentation of this file.

#ifndef __vtkCacheManager_h
#define __vtkCacheManager_h
 
// MRML includes
#include "vtkMRML.h"
#include "vtkMRMLScene.h"
class vtkCallbackCommand;
 
// VTK includes
#include <vtkObject.h>
#include <vtkWeakPointer.h>
 
// STD includes
#include <string>
#include <vector>
#include <map>
 
#ifndef vtkObjectPointer
# define vtkObjectPointer(xx) (reinterpret_cast<vtkObject**>((xx)))
#endif

class VTK_MRML_EXPORT vtkCacheManager : public vtkObject
{
public:
  static vtkCacheManager* New();
  vtkTypeMacro(vtkCacheManager, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void SetMRMLScene(vtkMRMLScene* scene) { this->MRMLScene = scene; }

  virtual void SetRemoteCacheDirectory(const char* dir);
  virtual void SetRemoteCacheDirectory(const std::string& dir) { this->SetRemoteCacheDirectory(dir.c_str()); }

  const char* GetRemoteCacheDirectory();

  vtkGetMacro(RemoteCacheLimit, int);
  vtkSetMacro(RemoteCacheLimit, int);

  void UpdateCacheInformation();

  float GetCurrentCacheSize();
  float GetFreeCacheSpaceRemaining();
  std::vector<std::string> GetCachedFiles() const;

  struct CacheEntry
  {
    std::string Path;
    unsigned long long SizeBytes;
    long long ModifiedTime;
    bool IsDirectory;
    int FileCount;         
    bool ExceedsCacheSize; 
  };

  std::vector<CacheEntry> GetCacheEntries() const;

  bool PruneCache();

  bool ClearCache();

  void DeleteFromCache(const char* target);
  void DeleteFromCache(const std::string& filename);

  virtual bool IsRemoteReference(const char* uri);

  virtual bool IsLocalReference(const char* uri);

  virtual bool LocalFileExists(const char* uri);

  std::string FindCachedFile(const char* target, const char* dirname);

  virtual bool CachedFileExists(const char* filename);
  virtual bool CachedFileExists(const std::string& filename);

  std::string GetFilenameFromURI(const char* uri);
  std::string GetFilenameFromURI(const std::string& uri);
  std::string EncodeURI(const char* uri);

  std::string GetSentinelFileName() const;
  bool HasSentinelFile() const;
  bool CreateSentinelFile() const;

  bool IsDirectoryEmpty(const std::string& directoryPath) const;
  bool HasSentinelFileInDirectory(const std::string& directoryPath) const;
  bool CreateSentinelFileInDirectory(const std::string& directoryPath) const;
  std::vector<std::string> GetCachedFilesInDirectory(const std::string& directoryPath);
 
  vtkGetMacro(EnableForceRedownload, int);
  vtkSetMacro(EnableForceRedownload, int);
 
  vtkGetMacro(InsufficientFreeBufferNotificationFlag, int);
  vtkSetMacro(InsufficientFreeBufferNotificationFlag, int);
 
  void MapFileToURI(const char* uri, const char* fname);

  enum
  {
    NoCachedFile = 0,
    OldCachedFile,
    CachedFile
  };
 
  enum
  {
    InsufficientFreeBufferEvent = 21000,
    CacheLimitExceededEvent,
    CacheDeleteEvent,
    CacheDirtyEvent,
    CacheClearEvent
  };
 
  const char* GetFileFromURIMap(const char* uri);
 
private:
  struct vtkCacheManagerCachedFile
  {
    std::string Path;
    long long ModifiedTime;
  };
 
  vtkWeakPointer<vtkMRMLScene> MRMLScene;
  std::string RemoteCacheDirectory;
  std::map<std::string, std::string> UriMap;
  int InsufficientFreeBufferNotificationFlag;
  int RemoteCacheLimit;
  int EnableForceRedownload;
 
  std::vector<CacheEntry> CacheEntries;
  float CurrentCacheSize;
  bool UpdatingCacheInformation;
 
  bool CollectCachedFilesRecursively(const std::string& directoryPath, const std::string& rootDirectoryPath, std::vector<vtkCacheManagerCachedFile>& cachedFiles) const;

  void MarkNodesBeforeDeletingDataFromCache(const char*);
 
  void MarkNode(std::string);
 
  std::string CanonicalizePath(const char* path) const;
  std::string JoinPath(const std::string& directoryPath, const std::string& fileName) const;
  bool PathIsWithinDirectory(const std::string& directoryPath, const std::string& path) const;
 
  std::string GetSentinelFilePath(const char* cacheDirectory) const;
  std::string GetSentinelFilePath(const std::string& cacheDirectory) const;
 
  bool CanDeletePathInCache(const char* cacheDirectory, const char* pathToDelete, std::string& reason) const;
 
protected:
  vtkCacheManager();
  ~vtkCacheManager() override;
  vtkCacheManager(const vtkCacheManager&);
  void operator=(const vtkCacheManager&);

  vtkCallbackCommand* CallbackCommand;
};
 
#endif