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) VTK_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();
  virtual ~vtkCacheManager();
  vtkCacheManager(const vtkCacheManager&);
  void operator=(const vtkCacheManager&);

  vtkCallbackCommand *CallbackCommand;

};

#endif