vtkCacheManager.h

Go to the documentation of this file.

#ifndef __vtkCacheManager_h
#define __vtkCacheManager_h
 
// MRML includes
#include "vtkMRML.h"
class vtkCallbackCommand;
class vtkMRMLScene;
 
// VTK includes
#include <vtkObject.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;
 
  vtkGetMacro(InsufficientFreeBufferNotificationFlag, int);
  vtkSetMacro(InsufficientFreeBufferNotificationFlag, int);

  virtual void SetRemoteCacheDirectory(const char* dir);

  const char* GetRemoteCacheDirectory();

  void UpdateCacheInformation();
  void DeleteFromCachedFileList(const char* target);
 
  // Description:
  void DeleteFromCache(const char* target);

  int ClearCache();
  int ClearCacheCheck();

  void MarkNodesBeforeDeletingDataFromCache(const char*);

  virtual int IsRemoteReference(const char* uri);
  virtual int IsLocalReference(const char* uri);

  virtual int LocalFileExists(const char* uri);

  const char* FindCachedFile(const char* target, const char* dirname);

  virtual int CachedFileExists(const char* filename);

  const char* GetFilenameFromURI(const char* uri);
  const char* AddCachePathToFilename(const char* filename);
  const char* EncodeURI(const char* uri);
 
  void CacheSizeCheck();
  void FreeCacheBufferCheck();
  float ComputeCacheSize(const char* dirname, unsigned long size);
  float GetCurrentCacheSize();
  float GetFreeCacheSpaceRemaining();
 
  std::vector<std::string> GetCachedFiles() const;

  vtkGetMacro(RemoteCacheLimit, int);
  vtkSetMacro(RemoteCacheLimit, int);
  vtkSetMacro(CurrentCacheSize, float);
  vtkGetMacro(RemoteCacheFreeBufferSize, int);
  vtkSetMacro(RemoteCacheFreeBufferSize, int);
  vtkGetMacro(EnableForceRedownload, int);
  vtkSetMacro(EnableForceRedownload, int);
  // vtkGetMacro ( EnableRemoteCacheOverwriting, int );
  // vtkSetMacro ( EnableRemoteCacheOverwriting, int );
  void SetMRMLScene(vtkMRMLScene* scene) { this->MRMLScene = scene; }
  void MapFileToURI(const char* uri, const char* fname);
 
  void MarkNode(std::string);
  enum
  {
    NoCachedFile = 0,
    OldCachedFile,
    CachedFile
  };

  enum
  {
    InsufficientFreeBufferEvent = 21000,
    CacheLimitExceededEvent,
    CacheDeleteEvent,
    CacheDirtyEvent,
    CacheClearEvent
  };
 
  std::map<std::string, std::string> uriMap;
  const char* GetFileFromURIMap(const char* uri);
 
private:
  int InsufficientFreeBufferNotificationFlag;
  int RemoteCacheLimit;
  float CurrentCacheSize;
  int RemoteCacheFreeBufferSize;
  int EnableForceRedownload;
  // int EnableRemoteCacheOverwriting;
  vtkMRMLScene* MRMLScene;
 
  std::string RemoteCacheDirectory;
  int GetCachedFileList(const char* dirname);
  std::vector<std::string> GetAllCachedFiles();
  std::vector<std::string> CachedFileList;
 
protected:
  vtkCacheManager();
  ~vtkCacheManager() override;
  vtkCacheManager(const vtkCacheManager&);
  void operator=(const vtkCacheManager&);

  vtkCallbackCommand* CallbackCommand;
};
 
#endif