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"
#include "vtkCommand.h"
class vtkMRMLStorableNode;
class vtkMRMLMessageCollection;
 
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) override;
 
  vtkMRMLNode* CreateNodeInstance() override = 0;

  virtual vtkMRMLStorableNode* GetStorableNode();

  void ReadXMLAttributes(const char** atts) override;

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

  virtual int WriteData(vtkMRMLNode* refNode);

  void WriteXML(ostream& of, int indent) override;

  void Copy(vtkMRMLNode* node) override;

  const char* GetNodeTagName() override = 0;

  vtkSetStringMacro(FileName);
  vtkGetStringMacro(FileName);

  virtual std::string GetSupportedFileExtension(const char* fileName = nullptr, 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);

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

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


  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); };
  void SetReadStateSkippedNoData() { this->SetReadState(this->SkippedNoData); };
  const char* GetStateAsString(int state);
  const char* GetReadStateAsString() { return this->GetStateAsString(this->ReadState); };


  vtkGetMacro(WriteState, int);
  void SetWriteState(int writeState);
  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); };
  void SetWriteStateSkippedNoData() { this->SetWriteState(this->SkippedNoData); };
  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);


  virtual void SetWriteFileFormat(const char* 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 = nullptr);

  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() = default;
 
    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();

  enum
  {
    CoordinateSystemRAS = 0,
    RAS = 0, 
    CoordinateSystemLPS = 1,
    LPS = 1, 
    CoordinateSystemType_Last
  };

  static const char* GetCoordinateSystemTypeAsString(int id);
  static int GetCoordinateSystemTypeFromString(const char* name);
 
  const vtkMRMLMessageCollection* GetUserMessages() const { return this->UserMessages; }
  vtkMRMLMessageCollection* GetUserMessages() { return this->UserMessages; }


  static std::string ClampFileName(const std::string& filename, int extensionLength, int maxFileNameLength, int hashLength = 4);

  void FixFileName();
 
protected:
  vtkMRMLStorageNode();
  ~vtkMRMLStorageNode() override;
  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;
 
  // Record warnings and errors associated with this
  // vtkMRMLStorableNode.
  vtkMRMLMessageCollection* UserMessages;
};
 
#endif