Writer.h

#ifndef FIRE_IO_H5_WRITER_H
#define FIRE_IO_H5_WRITER_H
 
// using HighFive
#include <highfive/H5File.hpp>
 
#include "fire/config/Parameters.h"
#include "fire/io/Atomic.h"
#include "fire/io/Constants.h"
 
namespace fire::io {
 
class Writer {
 public:
  Writer(const int& event_limit, const config::Parameters& ps);
 
  ~Writer();
 
  void flush();
 
  const std::string& name() const;
 
  void structure(const std::string& path, const std::pair<std::string,int>& type);
 
  inline std::size_t entries() const { return entries_; }
 
  template <typename AtomicType>
  void save(const std::string& path, const AtomicType& val) {
    static_assert(
        is_atomic_v<AtomicType>,
        "Type unsupported by HighFive as Atomic made its way to Writer::save");
    if (buffers_.find(path) == buffers_.end()) {
      // first save attempt, need to create the data set to be saved
      // - we pass the newly created dataset to the buffer to hold onto
      //    for flushing purposes
      // - the length of the buffer is the same size as the chunks in
      //    HDF5, this is done on purpose
      // - if the type is a bool, we define the HighFive type to be
      //    our custom enum which mimics the type used by h5py
      HighFive::DataType t;
      if constexpr (std::is_same_v<AtomicType,bool>) {
        t = create_enum_bool();
      } else {
        t = HighFive::AtomicType<AtomicType>();
      }
      auto ds = file_->createDataSet(path, space_, t, create_props_);
      ds.createAttribute(constants::TYPE_ATTR_NAME, boost::core::demangle(typeid(AtomicType).name()));
      ds.createAttribute(constants::VERS_ATTR_NAME, 0);
      buffers_.emplace(path, 
          std::make_unique<Buffer<AtomicType>>(rows_per_chunk_, ds));
    }
    dynamic_cast<Buffer<AtomicType>&>(*buffers_.at(path)).save(val);
  }
 
  friend std::ostream& operator<<(std::ostream& s, const Writer& w) {
    return s << "Writer(" << w.name() << ")";
  }
 
  Writer(const Writer&) = delete;
  void operator=(const Writer&) = delete;
 
 private:
  class BufferHandle {
   protected:
    std::size_t max_len_;
    HighFive::DataSet set_;
 
   public:
    explicit BufferHandle(std::size_t max, HighFive::DataSet s)
        : max_len_{max}, set_{s} {}
    virtual ~BufferHandle() = default;
    virtual void flush() = 0;
  };
 
  template <typename AtomicType>
  class Buffer : public BufferHandle {
    std::vector<AtomicType> buffer_;
    std::size_t i_file_;
 
   public:
    explicit Buffer(std::size_t max, HighFive::DataSet s)
        : BufferHandle(max, s), buffer_{}, i_file_{0} {
      buffer_.reserve(this->max_len_);
    }
    virtual ~Buffer() = default;
    void save(const AtomicType& val) {
      buffer_.push_back(val);
      if (buffer_.size() > this->max_len_) flush();
    }
 
    virtual void flush() final override {
      if (buffer_.size() == 0) return;
      std::size_t new_extent = i_file_ + buffer_.size();
      // throws if not created yet
      if (this->set_.getDimensions().at(0) < new_extent) {
        this->set_.resize({new_extent});
      }
      if constexpr (std::is_same_v<AtomicType, bool>) {
        // handle bool specialization
        std::vector<Bool> buff;
        buff.reserve(buffer_.size());
        for (const auto& v : buffer_) buff.push_back(v ? Bool::TRUE : Bool::FALSE);
        this->set_.select({i_file_}, {buffer_.size()}).write(buff);
      } else {
        this->set_.select({i_file_}, {buffer_.size()}).write(buffer_);
      }
      i_file_ += buffer_.size();
      buffer_.clear();
      buffer_.reserve(this->max_len_);
    }
  };
 
 private:
  std::unique_ptr<HighFive::File> file_;
  HighFive::DataSetCreateProps create_props_;
  HighFive::DataSpace space_;
  std::size_t entries_;
  std::size_t rows_per_chunk_;
  std::unordered_map<std::string, std::unique_ptr<BufferHandle>> buffers_;
};
 
}  // namespace fire::h5
 
#endif  // FIRE_H5_WRITER_H