Writer.h

#ifndef PACKING_UTILITY_WRITER_H_
#define PACKING_UTILITY_WRITER_H_
 
#include <fstream>
#include <iostream>  //debuggin
#include <string>
#include <type_traits>
#include <vector>
 
namespace packing {
namespace utility {
 
class Writer {
 public:
  Writer() { file_.unsetf(std::ios::skipws); }
 
  void open(const std::string& file_name) {
    file_.open(file_name, std::ios::out | std::ios::binary);
  }
 
  Writer(const std::string& file_name) : Writer() { this->open(file_name); }
 
  ~Writer() = default;
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  Writer& write(const WordType* w, std::size_t num) {
    file_.write(reinterpret_cast<const char*>(w), sizeof(WordType) * num);
    return *this;
  }
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  Writer& operator<<(const WordType& w) {
    return write(&w, 1);
  }
 
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  Writer& operator<<(const std::vector<WordType>& vec) {
    return write(vec.data(), vec.size());
  }
 
  template <typename ObjectType,
            std::enable_if_t<std::is_class<ObjectType>::value, bool> = true>
  Writer& operator<<(const ObjectType& o) {
    return o.write(*this);
  }
 
  template <typename ObjectType,
            std::enable_if_t<std::is_class<ObjectType>::value, bool> = true>
  Writer& operator<<(const std::vector<ObjectType>& vec) {
    for (auto const& o : vec)
      if (!o.write(*this)) return *this;
    return *this;
  }
 
  bool operator!() const { return file_.fail(); }
 
  operator bool() const { return !file_.fail(); }
 
 private:
  std::ofstream file_;
};  // RawDataFile
 
}  // namespace utility
}  // namespace packing
 
#endif  // PACKING_UTILITY_WRITER_H_