Tree.h

#pragma once
 
#include "hdtree/Branch.h"
 
namespace hdtree {
 
class Tree {
 public:
  static Tree load(const std::string& file_path, const std::string& tree_path);
  static Tree save(const std::string& file_path, const std::string& tree_path);
  static Tree inplace(const std::string& file_path,
                      const std::string& tree_path);
  static Tree transform(const std::pair<std::string, std::string>& src,
                        const std::pair<std::string, std::string>& dest);
 
  template <typename DataType>
  Branch<DataType>& branch(const std::string& branch_name) {
    if (branches_.find(branch_name) != branches_.end()) {
      throw HDTreeException(
          "Branch named '" + branch_name + "' was already initialized.",
          "This usually originates from more than one call to `tree.branch` "
          "and/or `tree.get` with the same input branch name.");
    }
    if (not writer_) {
      throw HDTreeException(
          "Attempting to sprout a new branch without writing.",
          "While it could make sense to have a \"tracking\" branch that "
          "only exists in memory, HDTree has decided to not support that.\n"
          "You should not call `tree.branch` on a tree that is not going "
          "to be writing its data into an output file.");
    }
    branches_[branch_name] = std::make_unique<Branch<DataType>>(branch_name);
    branches_[branch_name]->attach(*writer_);
    return dynamic_cast<Branch<DataType>&>(*branches_[branch_name]);
  }
 
  template <typename DataType>
  const Branch<DataType>& get(const std::string& branch_name,
                              bool write = false) {
    if (not reader_) {
      throw HDTreeException(
          "Attempting to 'get' a branch without reading.",
          "There is no reference for a tree to know how to retrieve a "
          "branch for you if there is no input file to try to get a branch "
          "from. Make sure you've loaded a tree if you wish to 'get' a branch."
          );
    }
    if (branches_.find(branch_name) != branches_.end()) {
      throw HDTreeException(
          "Branch named '" + branch_name + "' was already initialized.",
          "This usually originates from more than one call to `tree.branch` "
          "and/or `tree.get` with the same input branch name.");
    }
    branches_[branch_name] = std::make_unique<Branch<DataType>>(branch_name);
    branches_[branch_name]->attach(*reader_);
    if (not inplace_ and writer_ and write)
      branches_[branch_name]->attach(*writer_);
    return dynamic_cast<Branch<DataType>&>(*branches_[branch_name]);
  }
 
  template <class UnaryFunction>
  void for_each(UnaryFunction body) {
    if (not reader_) {
      throw HDTreeException(
          "No reader configured, so I don't know how many entries to loop for.",
          "While the 'for_each' helper function is useful for trees being read "
          "from a file, WITHOUT an input file, YOU must decide how many entries "
          "will be in the tree.\n"
          "REMEMBER: make sure to call tree.save() whenever you want an entry "
          "to be stored (for example at the end of the body of a for-loop)."
          );
    }
    for (std::size_t i{0}; i < this->entries_; i++) {
      this->load();
      body();
      this->save();
    }
  }
 
  void save();
 
  void load();
 
 private:
  Tree(const std::pair<std::string, std::string>& src,
       const std::pair<std::string, std::string>& dest);
 
 private:
  std::unordered_map<std::string, std::unique_ptr<BaseBranch>> branches_;
  std::optional<std::size_t> entries_;
  std::unique_ptr<Reader> reader_;
  std::unique_ptr<Writer> writer_;
  bool inplace_{false};
};
 
}  // namespace hdtree