Reader.h

#ifndef PACKING_UTILITY_READER_H_
#define PACKING_UTILITY_READER_H_
 
#include <fstream>
#include <iostream>  //debuggin
#include <string>
#include <type_traits>
#include <vector>
 
namespace packing {
namespace utility {
 
class Reader {
 public:
  Reader() { file_.unsetf(std::ios::skipws); }
 
  void open(const std::string& file_name) {
    file_.open(file_name, std::ios::in | std::ios::binary);
    file_.seekg(0, std::ios::end);
    file_size_ = file_.tellg();
    file_.seekg(0);
  }
 
  Reader(const std::string& file_name) : Reader() { this->open(file_name); }
 
  ~Reader() = default;
 
  void seek(int off, std::ios_base::seekdir dir = std::ios::beg) {
    file_.seekg(off, dir);
  }
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  void seek(int off, std::ios_base::seekdir dir = std::ios::beg) {
    seek(off * sizeof(WordType), dir);
  }
 
  int tell() { return file_.tellg(); }
 
  template <typename WordType>
  int tell() {
    return tell() / sizeof(WordType);
  }
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  Reader& read(WordType* w, std::size_t count) {
    file_.read(reinterpret_cast<char*>(w), sizeof(WordType) * count);
    return *this;
  }
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  Reader& operator>>(WordType& w) {
    return read(&w, 1);
  }
 
  template <typename ObjectType,
            std::enable_if_t<std::is_class<ObjectType>::value, bool> = true>
  Reader& operator>>(ObjectType& o) {
    return o.read(*this);
  }
 
  template <typename ContentType>
  Reader& read(std::vector<ContentType>& vec, std::size_t count,
               std::size_t offset = 0) {
    vec.resize(offset + count);
    for (std::size_t i{offset}; i < vec.size(); i++) {
      if (!(*this >> vec[i])) return *this;
    }
    return *this;
  }
 
  bool operator!() const { return file_.fail(); }
 
  operator bool() const { return !file_.fail(); }
 
  bool eof() { return file_.eof() or file_.tellg() == file_size_; }
 
 private:
  std::ifstream file_;
  std::size_t file_size_;
};  // RawDataFile
 
}  // namespace utility
}  // namespace packing
 
#endif  // PACKING_UTILITY_READER_H_