Reader.h

#ifndef FIRE_IO_H5_READER_H
#define FIRE_IO_H5_READER_H
 
// using HighFive
#include <highfive/H5File.hpp>
 
#include "fire/io/Reader.h"
#include "fire/io/Atomic.h"
 
namespace fire::io::h5 {
 
class Reader : public ::fire::io::Reader {
 public:
  Reader(const std::string& name);
 
  virtual void load_into(BaseData& d) final override;
 
  virtual std::vector<std::pair<std::string,std::string>> availableObjects() final override;
 
  virtual std::pair<std::string,int> type(const std::string& path) final override;
 
  virtual std::string name() const final override;
 
  std::vector<std::string> list(const std::string& group_path) const;
 
  HighFive::DataType getDataSetType(const std::string& dataset) const;
 
  HighFive::ObjectType getH5ObjectType(const std::string& path) const;
 
  std::string getTypeName(const std::string& obj_name) const;
 
  inline std::size_t entries() const final override { return entries_; }
 
  inline std::size_t runs() const final override { return runs_; }
 
  virtual bool canCopy() const final override { return true; }
 
  virtual void copy(unsigned long int i_entry, const std::string& path, 
      Writer& output) final override;
 
  template <typename AtomicType>
  void load(const std::string& path, AtomicType& val) {
    static_assert(
        is_atomic_v<AtomicType>,
        "Type not supported by HighFive atomic made its way to Reader::load");
    if (buffers_.find(path) == buffers_.end()) {
      // first load attempt, we will find out if dataset exists in file here
      buffers_.emplace(path, std::make_unique<Buffer<AtomicType>>(
                                 rows_per_chunk_, file_.getDataSet(path)));
    }
 
    dynamic_cast<Buffer<AtomicType>&>(*buffers_[path]).read(val);
  }
 
  Reader(const Reader&) = delete;
  void operator=(const Reader&) = delete;
 
 private:
  void mirror(const std::string& path, Writer& output);
 
 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 load() = 0;
  };
 
  template <typename AtomicType>
  class Buffer : public BufferHandle {
    std::vector<AtomicType> buffer_;
    std::size_t i_file_;
    std::size_t i_memory_;
    std::size_t entries_;
   public:
    explicit Buffer(std::size_t max, HighFive::DataSet s)
        : BufferHandle(max, s), buffer_{}, i_file_{0}, i_memory_{0} {
      // get the number of entries for later checking
      entries_ = this->set_.getDimensions().at(0);
      // do first load upon creation
      this->load();
    }
    virtual ~Buffer() = default;
    
    void read(AtomicType& out) {
      if (i_memory_ == buffer_.size()) this->load();
      out = buffer_[i_memory_];
      i_memory_++;
    }
    
    virtual void load() final override {
      // determine the length we want to request depending
      // on the number of entries left in the file
      std::size_t request_len = this->max_len_;
      if (request_len + i_file_ > entries_) {
        request_len = entries_ - i_file_;
        assert(request_len >= 0);
      }
      // load the next chunk into memory
      if constexpr (std::is_same_v<AtomicType,bool>) {
        std::vector<Bool> buff;
        buff.resize(request_len);
        this->set_.select({i_file_}, {request_len})
          .read(buff.data(),create_enum_bool());
        buffer_.reserve(buff.size());
        for (const auto& v : buff) buffer_.push_back(v == Bool::TRUE);
      } else {
        this->set_.select({i_file_}, {request_len}).read(buffer_);
      }
      // update indices
      i_file_ += buffer_.size();
      i_memory_ = 0;
    }
  };
 
 private:
  class MirrorObject {
    Reader& reader_;
    std::unique_ptr<BaseData> data_;
    std::unique_ptr<BaseData> size_member_;
    std::vector<std::unique_ptr<MirrorObject>> obj_members_;
    unsigned long int last_entry_{0};
 
   public:
    MirrorObject(const std::string& path, Reader& reader);
 
    void copy(unsigned long int i_entry, unsigned long int n, Writer& output);
  };
 
 private:
  HighFive::File file_;
  const std::size_t entries_;
  const std::size_t runs_;
  std::size_t rows_per_chunk_{10000};
  std::unordered_map<std::string, std::unique_ptr<BufferHandle>> buffers_;
  std::unordered_map<std::string, std::unique_ptr<MirrorObject>> mirror_objects_;
};  // Reader
 
}  // namespace fire::io::h5
 
#endif  // FIRE_IO_H5_READER_H