AtomicBranch.h

#pragma once
 
namespace hdtree {
 
template <typename AtomicType>
class Branch<AtomicType, std::enable_if_t<is_atomic_v<AtomicType>>>
    : public AbstractBranch<AtomicType> {
  class ReadBuffer {
    std::size_t max_len_;
    HighFive::DataSet set_;
    std::vector<AtomicType> buffer_;
    std::size_t i_file_;
    std::size_t i_memory_;
    std::size_t entries_;
    void read_chunk_from_disk() {
      // 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;
    }
 
   public:
    explicit ReadBuffer(std::size_t max, HighFive::DataSet s)
        : max_len_{max}, set_{s}, buffer_{}, i_file_{0}, i_memory_{0} {
      entries_ = this->set_.getDimensions().at(0);
      this->read_chunk_from_disk();
      // TODO deduce max_len from chunk size of dataset
    }
    void read(AtomicType& v) {
      if (i_memory_ == buffer_.size()) this->read_chunk_from_disk();
      v = buffer_[i_memory_];
      ++i_memory_;
    }
  };
  std::unique_ptr<ReadBuffer> read_buffer_;
 
  class WriteBuffer {
    std::size_t max_len_;
    HighFive::DataSet set_;
    std::vector<AtomicType> buffer_;
    std::size_t i_file_;
    void flush() {
      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_);
    }
 
   public:
    explicit WriteBuffer(std::size_t max, HighFive::DataSet s)
        : max_len_{max}, set_{s}, buffer_{}, i_file_{0} {
      buffer_.reserve(this->max_len_);
    }
 
    // flush before deleting
    ~WriteBuffer() { flush(); }
 
    void save(const AtomicType& val) {
      buffer_.push_back(val);
      if (buffer_.size() > this->max_len_) flush();
    }
  };
 
  std::unique_ptr<WriteBuffer> write_buffer_;
 
 public:
  explicit Branch(const std::string& branch_name, AtomicType* handle = nullptr)
      : AbstractBranch<AtomicType>(branch_name, handle) {}
 
  void attach(Reader& f) final override try {
    // deletes old read_buffer_ if there was one already constructed
    read_buffer_ =
        std::make_unique<ReadBuffer>(10000, f.getDataSet(this->name_));
  } catch (const HighFive::DataSetException& e) {
    // an exception was thrown when we tried to `get` the dataset by name
    std::stringstream msg, help;
    msg << "HDTreeBadType: Branch at " << this->name_
        << " could not be accessed.";
    help << "Check that this branch exists in your HDTree.\n"
            "    H5 Error: " << e.what();
    throw HDTreeException(msg.str(), help.str());
  }
 
  void load() final override {
    if (read_buffer_) read_buffer_->read(*(this->handle_));
  }
 
  void save() final override {
    if (write_buffer_) write_buffer_->save(*(this->handle_));
  }
 
  void attach(Writer& f) final override try {
    HighFive::DataType t;
    if constexpr (std::is_same_v<AtomicType, bool>) {
      t = create_enum_bool();
    } else {
      t = HighFive::AtomicType<AtomicType>();
    }
    auto ds = f.createDataSet(this->name_, t);
    ds.createAttribute(constants::TYPE_ATTR_NAME,
                       boost::core::demangle(typeid(AtomicType).name()));
    ds.createAttribute(constants::VERS_ATTR_NAME, 0);
    // flush and deletes old buffer if it exists
    write_buffer_ = std::make_unique<WriteBuffer>(f.getRowsPerChunk(), ds);
  } catch (const HighFive::DataSetException& e) {
    // an exception was thrown when we tried to create the dataset by name
    std::stringstream msg, help;
    msg << "HDTreeBadType: Branch at " << this->name_
        << " could not be created.";
    help << "Check that this branch does not already exist in your HDTree.\n"
            "      H5 Error:  " << e.what();
    throw HDTreeException(msg.str(), help.str());
  }
};  // Branch<AtomicType>
 
}  // namespace hdtree