pipe.h

Go to the documentation of this file.

 
#pragma once
#include <cstddef>
#include <vector>
#include <memory>
#include <b8/type.h>
namespace Pipe {
 
class CPipe {
protected:
  size_t _pushed_in_bytes = 0;
private:
  virtual bool  vOnPush( u8 x_ ){
    (void)x_;
    return false;
  }
public:
  bool Push(const std::string& str_) {
    bool failed = false;
    for( auto it : str_ ){
      if( ! Push( it ) ){
        failed = true;
      }
    }
    return failed ? false : true;
  }
 
  bool Push(u8 x_) {
    bool result = vOnPush(x_);
    if (result) ++_pushed_in_bytes;
    return result;
  }
 
protected:
  size_t _poped_in_bytes = 0;
private:
  virtual bool vOnPop(u8& x_) {
    (void)x_;
    return false;
  }
public:
  void SeekPop(size_t offset_ = 0) {
    _poped_in_bytes = offset_;
  }
 
  bool Pop(u8& x_) {
    const bool result = vOnPop(x_);
    if (result) ++_poped_in_bytes;
    return result;
  }
 
public:
  virtual ~CPipe() {}
};
 
class CNullPipe : public CPipe {
public:
  CNullPipe();
  virtual ~CNullPipe();
};
 
class CMemReaderPipe : public CPipe {
  const u8* _addr;
  size_t _bytesize;
 
  bool vOnPop(u8& x_) override {
    if (_poped_in_bytes < _bytesize) {
      x_ = *(_addr + _poped_in_bytes);
      return true;
    }
    return false;
  }
 
public:
  size_t Size() const {
    return _bytesize;
  }
 
  CMemReaderPipe(const u8* addr_, size_t bytesize_)
    : _addr(addr_),
      _bytesize(bytesize_) {}
};
 
class CMemBufferPipe : public CPipe {
public:
  std::vector<u8> _buff;
 
  void Dump();
 
  size_t Size() const {
    return _buff.size();
  }
private:
  bool vOnPush(u8 x_) override {
    _buff.push_back(x_);
    return true;
  }
 
  bool vOnPop(u8& x_) override {
    if (_poped_in_bytes < _buff.size()) {
      x_ = _buff[_poped_in_bytes];
      return true;
    }
    return false;
  }
};
 
class CFilePipe : public CPipe {
  FILE* _fp = nullptr;
private:
  bool vOnPush(u8 x_) override {
    fputc(x_, _fp);
    return true;
  }
 
  bool vOnPop(u8& x_) override {
    int c = fgetc(_fp);
    if (c != EOF) {
      x_ = c;
      return true;
    } else {
      return false;
    }
  }
public:
  CFilePipe(FILE* fp_) {
    _fp = fp_;
  }
};
 
extern void Move(
  std::shared_ptr< Pipe::CPipe > pipe_in_,
  std::shared_ptr< Pipe::CPipe > pipe_out_
);
 
} // namespace Pipe