StreamAccess.h

#pragma once
 
#include <cstdint>
 
#include <iolink/FlagSet.h>
#include <iolink/IOLinkAPI.h>
#include <iolink/storage/DataAccess.h>
 
namespace iolink
{
 
enum class StreamAccessCapability
{
  READ = 0x1,          
  WRITE = 0x2,         
  SEEK = 0x4,          
  MEMORY_ACCESS = 0x8, 
 
  READ_WRITE = 0x3, 
  READ_SEEK = 0x5,  
  WRITE_SEEK = 0x6, 
};
 
extern template class IOLINK_API_IMPORT FlagSet<StreamAccessCapability>;
 
using StreamAccessCapabilitySet = FlagSet<StreamAccessCapability>;
 
// Define bitwise operators for RandomAccessCapability
IOLINK_DEFINE_ENUM_BITWISE_OPERATORS(StreamAccessCapability)
 
 
enum class SeekOrigin
{
  BEGIN = 1,
  CURRENT = 2,
  END = 3,
};
 
class IOLINK_API StreamAccess : public DataAccess
{
public:
  virtual ~StreamAccess() = default;
 
  virtual StreamAccessCapabilitySet capabilities() const = 0;
 
  inline bool support(StreamAccessCapabilitySet flags) { return this->capabilities().has(flags); }
 
  virtual bool good() const;
 
  virtual bool eof() const = 0;
 
  /*
   * Checks if an error occured on the stream which forbids its use
   * Remark: 'end of file' is not considered as an error
   *
   * Default implementation returns false.
   *
   * @return true if an error occured, false otherwise
   */
  virtual bool fail() const = 0;
 
  // ==== //
  // READ //
  // ==== //
 
  virtual size_t read(size_t size, void* dst);
 
  virtual uint8_t peek();
 
  // ===== //
  // WRITE //
  // ===== //
 
  virtual size_t write(size_t size, const void* src);
 
  virtual void flush();
 
  // ==== //
  // SEEK //
  // ==== //
 
  virtual size_t tell();
 
  virtual void seek(int64_t offset, SeekOrigin origin);
 
  // ============= //
  // MEMORY_ACCESS //
  // ============= //
 
  virtual void* buffer();
 
  virtual const void* bufferReadOnly() const;
 
  virtual size_t bufferSize();
};
 
} // namespace iolink