MapBranch.h

#pragma once
 
namespace hdtree {
 
template <typename KeyType, typename ValType>
class Branch<std::map<KeyType, ValType>>
    : public AbstractBranch<std::map<KeyType, ValType>> {
  hdtree_class_version(1);
 
 public:
  explicit Branch(const std::string& branch_name,
                  std::map<KeyType, ValType>* handle = nullptr)
      : AbstractBranch<std::map<KeyType, ValType>>(branch_name, handle),
        size_{branch_name + "/" + constants::SIZE_NAME},
        keys_{branch_name + "/keys"},
        vals_{branch_name + "/vals"} {}
 
  void load() final override {
    size_.load();
    for (std::size_t i_map{0}; i_map < size_.get(); i_map++) {
      keys_.load();
      vals_.load();
      this->handle_->emplace(keys_.get(), vals_.get());
    }
  }
 
  void attach(Reader& f) final override {
    this->load_type_ = f.type(this->name_);
    size_.attach(f);
    keys_.attach(f);
    vals_.attach(f);
  }
 
  void save() final override {
    size_.update(this->handle_->size());
    size_.save();
    for (auto const& [key, val] : *(this->handle_)) {
      keys_.update(key);
      keys_.save();
      vals_.update(val);
      vals_.save();
    }
  }
 
  void attach(Writer& f) final override {
    f.structure(this->name_, this->save_type_);
    size_.attach(f);
    keys_.attach(f);
    vals_.attach(f);
  }
 
 private:
  Branch<std::size_t> size_;
  Branch<KeyType> keys_;
  Branch<ValType> vals_;
};  // Branch<std::map>
 
}  // namespace hdtree