OnDemandContainer.h

Go to the documentation of this file.

 
#include "TTree.h"
 
#include <iostream>
#include <limits>
 
#ifndef NAIA_OnDemandContainer_h
#define NAIA_OnDemandContainer_h
 
namespace NAIA {
 
template <class T> class OnDemandContainer {
public:
  OnDemandContainer() = default;
 
  void LoadEvent() {
    if (!m_cacheIsValid && m_ioEnabled) {
      m_branch->GetEntry(m_treeEntry);
      m_cacheIsValid = true;
    }
    // std::cout << m_branch << " thisEntry: " << m_branch->GetReadEntry()
    //           << " motherEntry: " << m_branch->GetMother()->GetReadEntry() << '\n';
  }
 
  void SetTreeEntry(unsigned long long treeEntry) {
    if (treeEntry == m_treeEntry)
      return;
    m_treeEntry = treeEntry;
    m_cacheIsValid = false;
  }
 
  void Branch(TTree *tree) {
    if (m_ioEnabled)
      tree->Branch(T::BranchName.c_str(), static_cast<T *>(this));
  }
 
  void MirrorBranch(TTree *targetTree, const T *sourceContainer) {
    // I'd like to avoid const_cast but TTree::Branch doesn't support const T* as a type
    // for the input buffer
    if (m_ioEnabled)
      targetTree->Branch(T::BranchName.c_str(), const_cast<T *>(sourceContainer));
  }
 
  void SetBranchAddress(TTree *tree) {
    // ROOT needs the address of the pointer to the buffer object.
    myPtrAddress = static_cast<T *>(this);
    tree->SetBranchAddress(T::BranchName.c_str(), &myPtrAddress);
    m_branch = tree->GetBranch(T::BranchName.c_str());
    if (!m_branch)
      m_ioEnabled = false;
  }
 
  void DisableIO() const { m_ioEnabled = false; }
 
  T *operator->() {
    if (!m_ioEnabled) {
      throw std::runtime_error(T::BranchName + ": this container is not available on file");
    }
    LoadEvent();
 
    // VERY IMPORTANT: don't use "this" here, it will point to the "previous" event
    return myPtrAddress;
  }
 
private:
  T *myPtrAddress;                                                                 
  TBranch *m_branch = nullptr;                                                     
  unsigned long long m_treeEntry = std::numeric_limits<unsigned long long>::max(); 
 
  mutable bool m_cacheIsValid = false; 
  mutable bool m_ioEnabled = true;     
};
} // namespace NAIA
#endif