bufferstate.h

Go to the documentation of this file.

#include <algorithm>
#include <cassert>
#include <concepts>
#include <cstddef>
#include <cstdio>
#include <memory>
#include <utility>
 
#ifndef ADOLC_BUFFER_STATE
#define ADOLC_BUFFER_STATE
 
namespace ADOLC::detail {
 
template <class T, class ElementType>
concept BufferStateType =
    requires(T &buffer, const T &constBuffer, const char *fileName,
             const char *mode, size_t position, size_t numOnTape) {
      { buffer.begin() } -> std::same_as<ElementType *>;
      { constBuffer.begin() } -> std::same_as<const ElementType *>;
      { buffer.file() } -> std::same_as<FILE *>;
      { constBuffer.file() } -> std::same_as<FILE *>;
      { constBuffer.position() } -> std::convertible_to<size_t>;
      buffer.position(position);
      { constBuffer.numOnTape() } -> std::convertible_to<size_t>;
      buffer.numOnTape(numOnTape);
      buffer.openFile(fileName, mode);
      buffer.closeFile();
    };
 
struct FileDeleter {
  int operator()(FILE *file) { return fclose(file); }
};
 
inline constexpr auto fileDeleter = FileDeleter{};
 
struct BufferViewTag {};
inline constexpr BufferViewTag bufferView;
 
template <typename T> class BufferState {
  using FilePtr = std::unique_ptr<FILE, FileDeleter>;
  FilePtr file_{nullptr, fileDeleter};
  T *buffer_{nullptr};
  size_t currentPos_{0};
  size_t capacity_{0};
  size_t numOnTape_{0};
  bool owner_{true};
 
  void copyBuffer(const BufferState &other) {
    T *newBuffer = nullptr;
    if (other.buffer_ != nullptr) {
      newBuffer = new T[other.capacity_];
      std::copy_n(other.buffer_, other.capacity_, newBuffer);
    }
 
    if (owner_) {
      delete[] buffer_;
    }
    buffer_ = newBuffer;
    currentPos_ = other.currentPos_;
    capacity_ = other.capacity_;
    numOnTape_ = other.numOnTape_;
    owner_ = true;
  }
 
  void moveData(BufferState &&other) {
    file_ = std::move(other.file_);
    other.file_ = nullptr;
    if (owner_) {
      delete[] buffer_;
    }
    buffer_ = other.buffer_;
    other.buffer_ = nullptr;
    capacity_ = other.capacity_;
    currentPos_ = other.currentPos_;
    numOnTape_ = other.numOnTape_;
    other.currentPos_ = 0;
    other.capacity_ = 0;
    other.numOnTape_ = 0;
    owner_ = std::exchange(other.owner_, false);
  }
 
public:
  ~BufferState() {
    if (owner_) {
      delete[] buffer_;
    }
  }
 
  BufferState() = default;
 
  BufferState(T *buffer, size_t capacity)
      : buffer_(buffer), capacity_(capacity) {};
 
  BufferState(const BufferState &other) { copyBuffer(other); }
 
  BufferState(const BufferState &other, BufferViewTag)
      : buffer_(other.buffer_), currentPos_(other.currentPos_),
        capacity_(other.capacity_), numOnTape_(other.numOnTape_),
        owner_(false) {}
 
  BufferState &operator=(const BufferState &other) {
    if (this != &other) {
      copyBuffer(other);
      file_.reset();
    }
    return *this;
  }
 
  BufferState(BufferState &&other) noexcept { moveData(std::move(other)); }
 
  BufferState &operator=(BufferState &&other) noexcept {
    if (this != &other) {
      moveData(std::move(other));
    }
    return *this;
  }
 
  bool isOwner() const { return owner_; }
 
  void allocateAndOwn() {
    if (owner_) {
      return;
    }
    buffer_ = new T[capacity_];
    owner_ = true;
  }
  void resetFile(FILE *file) { file_.reset(file); }
 
  FILE *file() { return file_.get(); }
  FILE *file() const { return file_.get(); }
 
  void closeFile() { file_.reset(); }
 
  FILE *releaseFile() { return file_.release(); }
 
  void openFile(const char *fileName, const char *mode) {
    file_.reset(fopen(fileName, mode));
  }
 
  void resetBuffer(T *buffer, size_t capacity) {
    if (owner_) {
      delete[] buffer_;
    }
    buffer_ = buffer;
    capacity_ = capacity;
    currentPos_ = 0;
    owner_ = true;
  }
 
  T *begin() { return buffer_; }
  const T *begin() const { return buffer_; }
 
  T *releaseBuffer() {
    assert(owner_ && "You can not release a borrowed buffer!");
    T *buffer = buffer_;
    buffer_ = nullptr;
    capacity_ = 0;
    currentPos_ = 0;
    return buffer;
  }
 
  void allocIfNull(size_t capacity) {
    if (buffer_ == nullptr) {
      buffer_ = new T[capacity];
      capacity_ = capacity;
      owner_ = true;
    }
  }
 
  size_t position() const { return currentPos_; }
 
  void position(size_t pos) {
    assert(pos <= capacity_);
    currentPos_ = pos;
  }
 
  size_t remainingCapacity() const { return capacity_ - currentPos_; }
 
  size_t capacity() const { return capacity_; }
 
  size_t numOnTape() const { return numOnTape_; }
 
  void numOnTape(size_t num) { numOnTape_ = num; }
 
  const T &operator[](size_t idx) const {
    assert(idx < capacity_);
    return buffer_[idx];
  }
 
  T &operator[](size_t idx) {
    assert(idx < capacity_);
    return buffer_[idx];
  }
 
  void writeCurrent(T val) {
    assert(currentPos_ < capacity_);
    buffer_[currentPos_] = val;
  }
 
  void writeAndAdvance(T val) {
    writeCurrent(val);
    advance();
  }
 
  T *current() { return buffer_ + currentPos_; }
  const T *current() const { return buffer_ + currentPos_; }
 
  void advance() {
    assert(currentPos_ < capacity_);
    ++currentPos_;
  }
 
  void retreat() {
    assert(currentPos_ > 0);
    --currentPos_;
  }
 
  T readAndAdvance() { return (*this)[currentPos_++]; }
 
  T retreatAndRead() { return (*this)[--currentPos_]; }
};
 
using OpBuffer = BufferState<unsigned char>;
using ValBuffer = BufferState<double>;
using LocBuffer = BufferState<size_t>;
using TayBuffer = BufferState<double>;
}; // namespace ADOLC::detail
#endif // ADOLC_BUFFER_STATE