Reader.h

#pragma once
 
#include <type_traits>
#include <vector>
 
namespace pflib::packing {
 
class Reader {
 public:
  Reader() = default;
 
  virtual ~Reader() = default;
 
  virtual void seek(int off) = 0;
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  void seek(int off) {
    seek(off * sizeof(WordType));
  }
  void seek(int off) {…}
 
  virtual int tell() = 0;
 
  template <typename WordType>
  int tell() {
    return tell() / sizeof(WordType);
  }
  int tell() {…}
 
  virtual Reader& read(char* w, std::size_t count) = 0;
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  Reader& read(WordType* w, std::size_t count) {
    return read(reinterpret_cast<char*>(w), sizeof(WordType)*count);
  }
  Reader& read(WordType* w, std::size_t count) {…}
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  Reader& operator>>(WordType& w) {
    return read(&w, 1);
  }
  Reader& operator>>(WordType& w) {…}
 
  template <typename ObjectType,
            std::enable_if_t<std::is_class<ObjectType>::value, bool> = true>
  Reader& operator>>(ObjectType& o) {
    return o.read(*this);
  }
  Reader& operator>>(ObjectType& o) {…}
 
  template <typename ContentType>
  Reader& read(std::vector<ContentType>& vec, std::size_t count, std::size_t offset = 0) {
    vec.resize(count+offset);
    for (std::size_t i{offset}; i < vec.size(); i++) {
      if (!(*this >> vec[i])) return *this;
    }
    return *this;
  }
  Reader& read(std::vector<ContentType>& vec, std::size_t count, std::size_t offset = 0) {…}
 
  virtual bool good() const = 0;
 
  virtual bool operator!() const {
    return !good();
  }
  virtual bool operator!() const  {…}
 
  virtual operator bool() const {
    return good();
  }
  virtual operator bool() const  {…}
 
  virtual bool eof() = 0;
};  // Reader
class Reader {…};
 
}  // namespace pflib::packing