file.hpp

Go to the documentation of this file.

#pragma once
#ifndef _QICORE_FILE_HPP_
#define _QICORE_FILE_HPP_
/*
**  Copyright (C) 2013 Aldebaran Robotics
**  See COPYING for the license
*/

#include <iosfwd>
#include <cassert>

#include <qicore/api.hpp>
#include <qi/anyobject.hpp>
#include <qi/path.hpp>
#include <qi/future.hpp>
#include <qi/buffer.hpp>
#include <qi/property.hpp>

#include <boost/shared_ptr.hpp>

namespace qi
{
class QICORE_API ProgressNotifier
{
protected:
  ProgressNotifier()
  {
  }

public:
  virtual ~ProgressNotifier()
  {
  }

  enum Status
  {
    Status_Idle,      
    Status_Running,   
    Status_Finished,  
    Status_Failed,    
    Status_Cancelled, 
  };

  Property<Status> status;

  Property<double> progress;
  virtual bool isRunning() const = 0;

  // The following operations are reserved for the implementation of the associated operations.

  virtual void _reset() = 0;

  virtual void _notifyRunning() = 0;

  virtual void _notifyFinished() = 0;

  virtual void _notifyCancelled() = 0;

  virtual void _notifyFailed() = 0;

  virtual void _notifyProgressed(double newProgress) = 0;
};

typedef qi::Object<ProgressNotifier> ProgressNotifierPtr;

QICORE_API ProgressNotifierPtr createProgressNotifier();

class QICORE_API File
{
protected:
  File()
  {
  }

public:
  virtual ~File()
  {
  }

  virtual std::streamsize size() const = 0;

  virtual bool isOpen() const = 0;

  virtual bool isRemote() const = 0;

  virtual ProgressNotifierPtr operationProgress() const = 0;

  // The following operations are reserved for the implementation of file processing algorithms.

  static const std::streamsize MAX_READ_SIZE = 1000000;

  virtual Buffer _read(std::streamsize countBytesToRead) = 0;

  virtual Buffer _read(std::streamoff beginOffset, std::streamsize countBytesToRead) = 0;

  virtual bool _seek(std::streamoff offsetFromBegin) = 0;

  virtual void _close() = 0;
};

typedef qi::Object<File> FilePtr;

QICORE_API FilePtr openLocalFile(const qi::Path& localPath);

class FileOperation : public ProgressNotifier
{
public:
  virtual ~FileOperation()
  {
  }

  virtual Future<void> start() = 0;

private:
};

typedef boost::shared_ptr<FileOperation> FileOperationPtr;

QICORE_API FileOperationPtr prepareCopyToLocal(FilePtr file, const Path& localPath);

QICORE_API FutureSync<void> copyToLocal(FilePtr file, const Path& localPath);
}

QI_TYPE_INTERFACE(File);
QI_TYPE_INTERFACE(ProgressNotifier);
QI_TYPE_ENUM_REGISTER(ProgressNotifier::Status);

#endif // _QI_FILE_HPP_