vtkDataTransfer.h

Go to the documentation of this file.

#ifndef __vtkDataTransfer_h
#define __vtkDataTransfer_h

// MRML includes
#include "vtkMRML.h"
class vtkURIHandler;

// VTK includes
#include <vtkObject.h>

class VTK_MRML_EXPORT vtkDataTransfer : public vtkObject
{
  public:

  static vtkDataTransfer *New();
  vtkTypeMacro(vtkDataTransfer, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  vtkGetStringMacro ( SourceURI );
  vtkSetStringMacro ( SourceURI );
  vtkGetStringMacro ( DestinationURI );
  vtkSetStringMacro ( DestinationURI );
  vtkGetObjectMacro ( Handler, vtkURIHandler );
  virtual void SetHandler(vtkURIHandler* uriHandler);
  vtkGetMacro ( TransferType, int );
  vtkSetMacro ( TransferType, int );
  vtkGetMacro ( TransferID, int );
  vtkSetMacro ( TransferID, int );
  vtkGetMacro ( SizeOnDisk, int );
  vtkSetMacro ( SizeOnDisk, int );
  vtkGetStringMacro ( TransferNodeID);
  vtkSetStringMacro ( TransferNodeID);
  vtkGetMacro ( Progress, int );
  vtkSetMacro ( Progress, int );
  vtkGetMacro ( TransferStatus, int );
  vtkSetMacro ( TransferStatus, int );

  vtkGetMacro ( CancelRequested, int );
  vtkSetMacro ( CancelRequested, int );

  vtkGetMacro (TransferCached, int );
  vtkSetMacro (TransferCached, int );

  void SetTransferStatusNoModify ( int val)
      {
      this->TransferStatus = val;
      }

  const char* GetTransferStatusString( ) {
    switch (this->TransferStatus)
      {
      case vtkDataTransfer::Idle: return "Idle";
      case vtkDataTransfer::CancelPending: return "CancelPending";
      case vtkDataTransfer::Pending: return "Pending";
      case vtkDataTransfer::Running: return "Running";
      case vtkDataTransfer::Completed: return "Completed";
      case vtkDataTransfer::CompletedWithErrors: return "CompletedWithErrors";
      case vtkDataTransfer::TimedOut: return "TimedOut";
      case vtkDataTransfer::Cancelled: return "Cancelled";
      case vtkDataTransfer::Deleted: return "Deleted";
      case vtkDataTransfer::Ready: return "Ready";
      }
    return "Unknown";
  }

  const char* GetTransferTypeString( ) {
    switch (this->TransferType)
      {
      case vtkDataTransfer::RemoteDownload: return "RemoteDownload";
      case vtkDataTransfer::RemoteUpload: return "RemoteUpload";
      case vtkDataTransfer::LocalLoad: return "LocalUpload";
      case vtkDataTransfer::LocalSave: return "LocalSave";
      case vtkDataTransfer::Unspecified: return "Unspecified";
      }
    return "Unknown";
  }

  enum
    {
      Idle=0,
      Pending,
      Running,
      Completed,
      CompletedWithErrors,
      CancelPending,
      Cancelled,
      Ready,
      Deleted,
      TimedOut
    };
  enum
    {
      RemoteDownload=0,
      RemoteUpload,
      LocalLoad,
      LocalSave,
      Unspecified
    };

 private:

 protected:
  vtkDataTransfer();
  ~vtkDataTransfer() override;
  vtkDataTransfer(const vtkDataTransfer&);
  void operator=(const vtkDataTransfer&);

  char *SourceURI;
  char *DestinationURI;
  vtkURIHandler *Handler;
  int TransferStatus;
  int TransferID;
  int TransferType;
  int TransferCached;
  int SizeOnDisk;
  char* TransferNodeID;
  int Progress;
  int CancelRequested;

};

#endif