vtkMRMLStorageNode.h

Go to the documentation of this file.

/*=auto=========================================================================

  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.

  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Program:   3D Slicer
  Module:    $RCSfile: vtkMRMLStorageNode.h,v $
  Date:      $Date: 2006/03/19 17:12:29 $
  Version:   $Revision: 1.3 $

=========================================================================auto=*/

#ifndef __vtkMRMLStorageNode_h
#define __vtkMRMLStorageNode_h

// MRML includes
#include "vtkMRMLNode.h"
class vtkMRMLStorableNode;

class vtkURIHandler;

// VTK includes
class vtkStringArray;

// STD includes
#include <vector>

class VTK_MRML_EXPORT vtkMRMLStorageNode : public vtkMRMLNode
{
public:
  vtkTypeMacro(vtkMRMLStorageNode,vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  virtual vtkMRMLNode* CreateNodeInstance() VTK_OVERRIDE = 0;

  virtual vtkMRMLStorableNode* GetStorableNode();

  virtual void ReadXMLAttributes( const char** atts) VTK_OVERRIDE;

  virtual int ReadData(vtkMRMLNode *refNode, bool temporaryFile = false);

  virtual int WriteData(vtkMRMLNode *refNode);

  virtual void WriteXML(ostream& of, int indent) VTK_OVERRIDE;

  virtual void Copy(vtkMRMLNode *node) VTK_OVERRIDE;

  virtual const char* GetNodeTagName() VTK_OVERRIDE = 0;

  vtkSetStringMacro(FileName);
  vtkGetStringMacro(FileName);

  virtual std::string GetSupportedFileExtension(const char* fileName = NULL, bool includeReadable = true, bool includeWriteable = true);

  const char *GetNthFileName(int n) const;

  vtkBooleanMacro(UseCompression, int);
  vtkGetMacro(UseCompression, int);
  vtkSetMacro(UseCompression, int);

  vtkSetStringMacro(URI);
  vtkGetStringMacro(URI);

  vtkGetObjectMacro (URIHandler, vtkURIHandler);
  virtual void SetURIHandler(vtkURIHandler* uriHandler);

  virtual void ProcessMRMLEvents ( vtkObject *caller, unsigned long event, void *callData ) VTK_OVERRIDE;

  enum
  {
    Idle,
    Pending,
    Scheduled,
    Transferring,
    TransferDone,
    Cancelled
  };

  vtkGetMacro(ReadState,int);
  vtkSetMacro(ReadState,int);
  void SetReadStatePending() { this->SetReadState(this->Pending); };
  void SetReadStateIdle() { this->SetReadState(this->Idle); };
  void SetReadStateScheduled() { this->SetReadState(this->Scheduled); };
  void SetReadStateTransferring() { this->SetReadState(this->Transferring); };
  void SetReadStateTransferDone() { this->SetReadState(this->TransferDone); };
  void SetReadStateCancelled() { this->SetReadState(this->Cancelled); };
  const char *GetStateAsString(int state);
  const char *GetReadStateAsString() { return this->GetStateAsString(this->ReadState); };

  vtkGetMacro(WriteState,int);
  vtkSetMacro(WriteState,int);
  void SetWriteStatePending() { this->SetWriteState(this->Pending); };
  void SetWriteStateIdle() { this->SetWriteState(this->Idle); };
  void SetWriteStateScheduled() { this->SetWriteState(this->Scheduled); };
  void SetWriteStateTransferring() { this->SetWriteState(this->Transferring); };
  void SetWriteStateTransferDone() { this->SetWriteState(this->TransferDone); };
  void SetWriteStateCancelled() { this->SetWriteState(this->Cancelled); };
  const char *GetWriteStateAsString() { return this->GetStateAsString(this->WriteState); };

  std::string GetFullNameFromFileName();
  std::string GetFullNameFromNthFileName(int n);

  virtual int SupportedFileType(const char *fileName);

  virtual vtkStringArray* GetSupportedReadFileTypes();

  virtual vtkStringArray* GetSupportedWriteFileTypes();

  virtual void GetFileExtensionsFromFileTypes(vtkStringArray* inputFileTypes, vtkStringArray* outputFileExtensions);

  vtkSetStringMacro(WriteFileFormat);
  vtkGetStringMacro(WriteFileFormat);

  unsigned int AddFileName (const char *fileName);
  void ResetFileNameList();

  int GetNumberOfFileNames() const
  {
    return (int)this->FileNameList.size();
  };

  int FileNameIsInList(const char *fileName);

  unsigned int AddURI(const char *uri);

  const char *GetNthURI(int n);

  void ResetURIList();

  int GetNumberOfURIs()
  {
    return (int)this->URIList.size();
  }

  void SetDataDirectory(const char* dataDirName);
  void SetURIPrefix(const char *uriPrefix);

  virtual const char* GetDefaultWriteFileExtension();

  virtual void SetDefaultWriteFileExtension(const char* ext);

  void ResetNthFileName(int n, const char *fileName);
  void ResetNthURI(int n, const char *uri);

  int IsFilePathRelative(const char * filepath);

  const char *GetAbsoluteFilePath(const char *inputPath);

  vtkSetStringMacro(TempFileName);
  vtkGetStringMacro(TempFileName);

  void InvalidateFile();

  vtkTimeStamp GetStoredTime();

  virtual bool CanReadInReferenceNode(vtkMRMLNode* refNode) = 0;
  virtual bool CanWriteFromReferenceNode(vtkMRMLNode* refNode);

  virtual void ConfigureForDataExchange() {};

  static std::string GetLowercaseExtensionFromFileName(const std::string& filename);

  std::string GetFileNameWithoutExtension(const char* fileName = NULL);

  vtkSetMacro(CompressionParameter, std::string);
  vtkGetMacro(CompressionParameter, std::string);

  virtual std::vector<std::string> GetCompressionPresetDisplayNames();

  virtual std::string GetCompressionParameterFromDisplayName(const std::string& name);

  virtual std::string GetDisplayNameFromCompressionParameter(const std::string& preset);

  virtual int GetNumberOfCompressionPresets();

  struct CompressionPreset
  {
    CompressionPreset()
    {
    }

    CompressionPreset(const std::string &parameter, const std::string &name)
      : CompressionParameter(parameter)
      , DisplayName(name)
    {
    }

    std::string CompressionParameter;
    std::string DisplayName;
  };

  virtual const std::vector<CompressionPreset> GetCompressionPresets();

protected:
  vtkMRMLStorageNode();
  ~vtkMRMLStorageNode();
  vtkMRMLStorageNode(const vtkMRMLStorageNode&);
  void operator=(const vtkMRMLStorageNode&);

  virtual int ReadDataInternal(vtkMRMLNode* refNode);

  virtual int WriteDataInternal(vtkMRMLNode* refNode);

  void StageReadData ( vtkMRMLNode *refNode );

  void StageWriteData ( vtkMRMLNode *refNode );

  char *FileName;
  char *TempFileName;
  char *URI;
  vtkURIHandler *URIHandler;
  int UseCompression;
  int ReadState;
  int WriteState;
  std::string CompressionParameter;
  std::vector<CompressionPreset> CompressionPresets;

  std::vector<std::string> FileNameList;
  std::vector<std::string> URIList;
  vtkStringArray* SupportedReadFileTypes;

  std::string DefaultWriteFileExtension;
  vtkStringArray* SupportedWriteFileTypes;
  char* WriteFileFormat;

  virtual void InitializeSupportedReadFileTypes();
  virtual void InitializeSupportedWriteFileTypes();
  virtual void UpdateCompressionPresets();

  vtkTimeStamp* StoredTime;

  vtkWeakPointer<vtkMRMLStorableNode> LastFoundStorableNode;
};

#endif