vtkMRMLStorageNode.h

Go to the documentation of this file.

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

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

  See Doc/copyright/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

#include "vtkMRML.h"
#include "vtkMRMLNode.h"
#include "vtkMRMLScene.h"
#include "vtkURIHandler.h"

class vtkStringArray;
class vtkURIHandler;

class VTK_MRML_EXPORT vtkMRMLStorageNode : public vtkMRMLNode
{
  public:
  static vtkMRMLStorageNode *New(){return NULL;};
  vtkTypeMacro(vtkMRMLStorageNode,vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent);

  virtual vtkMRMLNode* CreateNodeInstance() = 0;

  virtual void ReadXMLAttributes( const char** atts);
  
  virtual int ReadData(vtkMRMLNode *refNode) = 0;

  virtual int WriteData(vtkMRMLNode *refNode) = 0;

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

  virtual void Copy(vtkMRMLNode *node);

  virtual const char* GetNodeTagName() = 0;

  vtkSetStringMacro(FileName);
  vtkGetStringMacro(FileName);
  const char *GetNthFileName(int n) const;

  vtkGetMacro(UseCompression, int);
  vtkSetMacro(UseCompression, int);
  vtkBooleanMacro(UseCompression, int);
  
  vtkSetStringMacro(URI);
  vtkGetStringMacro(URI);
  
  vtkGetObjectMacro (URIHandler, vtkURIHandler);
  vtkSetObjectMacro (URIHandler, vtkURIHandler);
  
  virtual void ProcessMRMLEvents ( vtkObject *caller, unsigned long event, void *callData );

  void StageReadData ( vtkMRMLNode *refNode );
  void StageWriteData ( vtkMRMLNode *refNode );

  //BTX
  enum
  {
    Idle,
    Pending,
    Scheduled,
    Transferring,
    TransferDone,
    Cancelled
  };
  //ETX
  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); };

  //BTX
  std::string GetFullNameFromFileName();
  std::string GetFullNameFromNthFileName(int n);
  //ETX

  virtual int SupportedFileType(const char *fileName);

  virtual vtkStringArray* GetSupportedWriteFileTypes();

  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()
    {
    return NULL;
    };

  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);
  
protected:
  vtkMRMLStorageNode();
  ~vtkMRMLStorageNode();
  vtkMRMLStorageNode(const vtkMRMLStorageNode&);
  void operator=(const vtkMRMLStorageNode&);
  
  char *FileName;
  char *TempFileName;
  char *URI;
  vtkURIHandler *URIHandler;
  int UseCompression;
  int ReadState;
  int WriteState;

  //BTX
  std::vector<std::string> FileNameList;
  std::vector<std::string> URIList;
  //ETX
  vtkStringArray* SupportedWriteFileTypes;
  char* WriteFileFormat;

  virtual void InitializeSupportedWriteFileTypes();

};

#endif