Reader.h

#ifndef FIRE_IO_ROOT_READER_H_
#define FIRE_IO_ROOT_READER_H_
 
#include <set>
 
#include "TFile.h"
#include "TTree.h"
#include "TBranch.h"
 
#include "fire/io/Reader.h"
#include "fire/exception/Exception.h"
 
namespace fire::io::root {
 
class Reader : public ::fire::io::Reader {
 public:
  Reader(const std::string& file_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;
 
  virtual std::size_t entries() const final override;
 
  virtual std::size_t runs() const final override;
 
  template <typename DataType>
  void load(const std::string& name, DataType& obj) {
    // transform h5 directory-style name into branchname
    // of ROOT-based framework
    std::string branch_name{transform(name)};
    if (attached_.find(branch_name) == attached_.end()) {
      TTree* tree{event_tree_};
      if (branch_name == "RunHeader") tree = run_tree_;
      attached_[branch_name] = attach(tree,branch_name,obj);
    }
    if (attached_[branch_name]->GetEntry(attached_[branch_name]->GetReadEntry()+1) < 0) {
      throw Exception("BadType",
          "ROOT was unable to deserialize the branch "+branch_name
          +" into the passed type "
          +boost::core::demangle(typeid(DataType).name())
          +".\n  This error is usually caused by not providing the correct"
          " ROOT dictionary for the type you are attempting to read.",false);
    }
  }
 
  Reader(const Reader&) = delete;
  void operator=(const Reader&) = delete;
 private:
  static std::string transform(const std::string& dir_name);
 
  template<typename T>
  TBranch* attach(TTree* tree, const std::string& branch_name, T& obj) {
    TBranch* br = tree->GetBranch(branch_name.c_str());
    if (br == 0) {
      throw Exception("NotFound", 
          "Branch "+branch_name+" not found in input ROOT file.");
    }
    if constexpr (std::numeric_limits<T>::is_specialized) {
      br->SetAddress(&obj);
    } else {
      br->SetObject(&obj);
    }
    br->SetStatus(1);
    return br;
  }
 private:
  TFile* file_;
  TTree* event_tree_;
  TTree* run_tree_;
  // branches that have been attached
  std::map<std::string, TBranch*> attached_;
};  // Reader
 
}  // namespace fire::io::root
 
#endif