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);
  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); };
  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);
 
  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 = 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; }
 
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