GeneralBranch.h

#pragma once
 
#include "hdtree/Exception.h"
 
namespace hdtree {
 
template <typename DataType, typename Enable = void>
class Branch : public AbstractBranch<DataType> {
 public:
  enum SaveLoad {
    Both,      
    LoadOnly,  
    SaveOnly   
  };
 
  explicit Branch(const std::string& branch_name, DataType* handle = nullptr)
      : AbstractBranch<DataType>(branch_name, handle) {
    hdtree::access::connect(*this->handle_, *this);
  }
 
  void load() final override try {
    for (auto& [save, load, m] : members_)
      if (load) m->load();
  } catch (const HighFive::DataSetException& e) {
    const auto& [memt, memv] = this->save_type_;
    const auto& [diskt, diskv] =
        this->load_type_.value_or(std::make_pair("NULL", -1));
    std::stringstream msg, help;
    msg << "HDTreeBadType: Branch at " << this->name_
        << " could not be loaded into " << memt << " (version " << memv
        << ") from the type it was written as " << diskt << " (version " << diskv
        << ")";
    help << "Check that your implementation of attach can handle any "
            "previous versions of your class you are trying to read.\n"
            "    Caused by: " << e.what();
    throw HDTreeException(msg.str(), help.str());
  }
 
  void attach(Reader& f) final override try {
    this->load_type_ = f.type(this->name_);
    for (auto& [save, load, m] : members_)
      if (load) m->attach(f);
  } catch (const HDTreeException& e) {
    const auto& [memt, memv] = this->save_type_;
    const auto& [diskt, diskv] = f.type(this->name_);
    std::stringstream msg, help;
    msg << "HDTreeBadType: Branch at " << this->name_
        << " could not be attached to " << memt << " (version " << memv
        << ") from the type it was written as " << diskt << " (version " << diskv
        << ")";
    help << "Check that your implementation of attach can handle any "
            "previous versions of your class you are trying to read.\n"
            "    Caused by: " << e.what();
    throw HDTreeException(msg.str(), help.str());
  }
 
  /*
   * Saving this dataset from the file involves simply saving
   * all of the members of the data type.
   */
  void save() final override {
    for (auto& [save, load, m] : members_)
      if (save) m->save();
  }
 
  void attach(Writer& f) final override {
    f.structure(this->name_, this->save_type_);
    for (auto& [save, load, m] : members_)
      if (save) m->attach(f);
  }
 
  template <typename MemberType>
  void attach(const std::string& name, MemberType& m,
              SaveLoad sl = SaveLoad::Both) {
    if (name == constants::SIZE_NAME) {
      throw HDTreeException(
          "HDTreeBadName: The member name '" + constants::SIZE_NAME +
          "' is not allowed due to "
          "its use in the serialization of variable length types.",
          "Please give your member a more detailed name corresponding to "
          "your class"
          );
    }
    bool save{false}, load{false};
    if (sl == SaveLoad::LoadOnly)
      load = true;
    else if (sl == SaveLoad::SaveOnly) {
      save = true;
    } else {
      save = true;
      load = true;
    }
    members_.push_back(std::make_tuple(
        save, load,
        std::make_unique<Branch<MemberType>>(this->name_ + "/" + name, &m)));
  }
 
  template <typename MemberType>
  void rename(const std::string& old_name, const std::string& new_name,
              MemberType& m) {
    attach(old_name, m, SaveLoad::LoadOnly);
    attach(new_name, m, SaveLoad::SaveOnly);
  }
 
 private:
  std::vector<std::tuple<bool, bool, std::unique_ptr<BaseBranch>>> members_;
  Reader* input_file_;
};  // Branch
 
}  // namespace hdtree