RootMergeable.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/pcore/Mergeable.h>
#include <framework/logging/Logger.h>
 
#include <TROOT.h>
#include <TFile.h>
#include <TList.h>
#include <TH1F.h>
#include <TH1D.h>
#include <TH2F.h>
#include <TNtuple.h>
 
namespace Belle2 {
  template <class T> class RootMergeable : public Mergeable {
  public:
    RootMergeable() : m_wrapped(nullptr) { }
    template<class ...Args> explicit RootMergeable(Args&& ... params) : m_wrapped(new T(std::forward<Args>(params)...))
    {
      m_wrapped->SetBit(TObject::kMustCleanup); //ensure RecursiveRemove() is called
      gROOT->GetListOfCleanups()->Add(this);
    }
 
    virtual ~RootMergeable()
    {
      gROOT->GetListOfCleanups()->Remove(this);
      delete m_wrapped;
    }
 
    void assign(T* p)
    {
      delete m_wrapped;
      m_wrapped = p;
      m_wrapped->SetBit(TObject::kMustCleanup);
    }
 
    T& get() { return *m_wrapped; }
 
    const T& get() const { return *m_wrapped; }
 
    void write(TDirectory* file)
    {
      if (m_wrapped->GetDirectory() != nullptr and m_wrapped->GetDirectory() != file) {
        B2ERROR("RootMergeable: wrapped object belongs to other file, Write() might crash. Make sure your histogram/ntuple already belongs to the file you want to save it to before filling (e.g. in initialize())");
      }
      file->cd();
      m_wrapped->Write(nullptr, TObject::kOverwrite);
      removeSideEffects();
    }
 
    virtual void merge(const Mergeable* other) override
    {
      auto* otherMergeable = const_cast<RootMergeable<T>*>(static_cast<const RootMergeable<T>*>(other));
      TList list;
      list.SetOwner(false);
      list.Add(&otherMergeable->get());
 
      m_wrapped->Merge(&list);
    }
 
    virtual void clear() override
    {
      m_wrapped->Reset();
    }
 
    virtual void removeSideEffects() override
    {
      if (!m_wrapped) return;
 
      m_wrapped->SetDirectory(nullptr);
      //if we are the only owner, this becomes unnecessary
      gROOT->GetListOfCleanups()->Remove(this);
    }
 
    virtual void RecursiveRemove(TObject* obj) override
    {
      if (obj == m_wrapped)
        m_wrapped = nullptr;
    }
 
  private:
    T* m_wrapped;
 
    ClassDefOverride(RootMergeable, 2); 
  };
}