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 SetMRMLScene ( vtkMRMLScene *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;
 
};
class VTK_MRML_EXPORT vtkCacheManager : public vtkObject {…};
 
#endif