RootTreeWriter.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef FRAMEWORK_ROOTTREEWRITER_H
#define FRAMEWORK_ROOTTREEWRITER_H
 
 
#include "Framework/RootSerializationSupport.h"
#include "Framework/InputRecord.h"
#include "Framework/DataRef.h"
#include "Framework/Logger.h"
#include <TFile.h>
#include <TTree.h>
#include <TBranch.h>
#include <TClass.h>
#include <vector>
#include <functional>
#include <string>
#include <stdexcept> // std::runtime_error
#include <type_traits>
#include <typeinfo>
#include <memory>     // std::make_unique
#include <functional> // std::function
#include <utility>    // std::forward
#include <algorithm>  // std::generate
#include <variant>
 
namespace o2
{
namespace framework
{
 
template <typename T>
struct get_function {
  using type = void;
};
 
template <typename Ret, typename Class, typename... Args>
struct get_function<Ret (Class::*)(Args...) const> {
  using type = std::function<Ret(Args...)>;
};
 
template <typename From, typename To, typename _ = void>
struct can_assign : public std::false_type {
};
 
template <typename From, typename To>
struct can_assign<
  From, To,
  std::conditional_t<
    false,
    class_member_checker<
      decltype(&From::operator())>,
    void>> : public std::is_same<typename get_function<decltype(&From::operator())>::type, To> {
};
 
class RootTreeWriter
{
 public:
  // use string as input binding to be used with DPL input API
  using key_type = std::string;
  // extract the branch index from DataRef, ~(size_t)) indicates "no data", then nothing
  // is extracted from input and writing is skipped
  using IndexExtractor = std::function<size_t(o2::framework::DataRef const&)>;
  // mapper between branch name and base/index
  using BranchNameMapper = std::function<std::string(std::string, size_t)>;
  // a custom callback to close the writer
  // writing of tree and closing of file need to be implemented, but the pointers
  // remain owned by the tool
  using CustomClose = std::function<void(TFile* file, TTree* tree)>;
 
  struct DefaultKeyExtractor {
    template <typename T>
    static key_type asString(T const& arg)
    {
      return arg;
    }
  };
 
  enum struct BranchVerbosity {
    Quiet,
    Medium,
    High,
  };
 
 
  template <typename T, typename KeyType = key_type, typename KeyExtractor = DefaultKeyExtractor>
  struct BranchDef {
    using type = T;
    using key_type = KeyType;
    using key_extractor = KeyExtractor;
    std::vector<key_type> keys;
    std::string branchName;
    size_t nofBranches = 1;
    IndexExtractor getIndex = nullptr;
    BranchNameMapper getName = nullptr;
 
    using Fill = std::function<void(TBranch& branch, T const&)>;
    using FillExt = std::function<void(TBranch& branch, T const&, DataRef const&)>;
    using Spectator = std::function<void(T const&)>;
    using SpectatorExt = std::function<void(T const&, DataRef const&)>;
    using BranchCallback = std::variant<std::monostate, Fill, FillExt, Spectator, SpectatorExt>;
    BranchCallback callback;
 
    BranchDef(key_type key, std::string _branchName, size_t _nofBranches = 1) : keys({key}), branchName(_branchName), nofBranches(_nofBranches) {}
 
    template <typename... Args>
    BranchDef(key_type key, std::string _branchName, Args&&... args) : keys({key}), branchName(_branchName), nofBranches(1)
    {
      init(std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    BranchDef(std::vector<key_type> vec, std::string _branchName, Args&&... args) : keys(vec), branchName(_branchName), nofBranches(1)
    {
      init(std::forward<Args>(args)...);
    }
 
    template <typename Arg, typename... Args>
    void init(Arg&& arg, Args&&... args)
    {
      using Type = std::decay_t<Arg>;
      if constexpr (can_assign<Type, IndexExtractor>::value) {
        getIndex = arg;
      } else if constexpr (can_assign<Type, BranchNameMapper>::value) {
        getName = arg;
      } else if constexpr (can_assign<Type, Fill>::value) {
        callback = arg;
      } else if constexpr (can_assign<Type, FillExt>::value) {
        callback = arg;
      } else if constexpr (can_assign<Type, Spectator>::value) {
        callback = arg;
      } else if constexpr (can_assign<Type, SpectatorExt>::value) {
        callback = arg;
      } else if constexpr (std::is_integral<Type>::value) {
        nofBranches = arg;
      } else {
        assertNoMatchingType(std::forward<Arg>(arg));
      }
      if constexpr (sizeof...(args) > 0) {
        init(std::forward<Args>(args)...);
      }
    }
 
    // wrap the non matching type assert into a function to better see type of argument
    // in the compiler error
    template <typename Arg>
    void assertNoMatchingType(Arg&& arg)
    {
      static_assert(always_static_assert_v<Arg>, "no matching function signature for passed object. Please check:\n- Is it a callable object?\n- Does it have correct parameters and return type?\n- Are all type correctly qualified");
    }
  };
 
  RootTreeWriter() = delete;
 
  ~RootTreeWriter()
  {
    close();
  }
 
  template <typename... Args>
  RootTreeWriter(const char* filename, // file name
                 const char* treename, // name of the tree to write to
                 Args&&... args)       // followed by branch definition
  {
    parseConstructorArgs(std::forward<Args>(args)...);
    if (!mTreeStructure) {
      std::runtime_error("Failed to create the branch configuration");
    }
    if (filename && treename) {
      init(filename, treename);
    }
  }
 
  void init(const char* filename, const char* treename, const char* treetitle = nullptr)
  {
    mFile = std::make_unique<TFile>(filename, "RECREATE", "", 505);
    mTree = std::make_unique<TTree>(treename, treetitle != nullptr ? treetitle : treename);
    mTree->SetDirectory(mFile.get());
    mTreeStructure->setup(mBranchSpecs, mTree.get());
  }
 
  void setBranchName(size_t index, const char* branchName)
  {
    auto& spec = mBranchSpecs.at(index);
    if (spec.getName) {
      // set the branch names for this group, we also amend if there is only one branch but
      // the callback is configured
      size_t idx = 0;
      std::generate(spec.names.begin(), spec.names.end(), [&]() { return spec.getName(branchName, idx++); });
    } else {
      // single branch for this definition
      spec.names.at(0) = branchName;
    }
  }
 
  template <typename ContextType>
  void operator()(ContextType&& context)
  {
    if (!mTree || !mFile || mFile->IsZombie()) {
      throw std::runtime_error("Writer is invalid state, probably closed previously");
    }
    // execute tree structure handlers and fill the individual branches
    mTreeStructure->exec(std::forward<ContextType>(context), mBranchSpecs);
    // Note: number of entries will be set when closing the writer
  }
 
  void close()
  {
    if (!mIsClosed) {
      mIsClosed = true;
      if (!mFile) {
        return;
      }
      if (mCustomClose) {
        mCustomClose(mFile.get(), mTree.get());
      } else {
        // set the number of elements according to branch content and write tree
        mTree->SetEntries();
        // use TFile::Write rather then TTree::Write since latter writes to default gDirectory
        mFile->Write();
        mFile->Close();
      }
      // this is a feature of ROOT, the tree belongs to the file and will be deleted
      // automatically
      mTree.release();
      mFile.reset(nullptr);
    }
  }
 
  void autoSave()
  {
    if (mIsClosed || !mFile) {
      return;
    }
    mTree->SetEntries();
    LOG(info) << "Autosaving " << mTree->GetName() << " at entry " << mTree->GetEntries();
    mTree->AutoSave("overwrite");
  }
 
  bool isClosed() const
  {
    return mIsClosed;
  }
 
  size_t getStoreSize() const
  {
    return (mTreeStructure != nullptr ? mTreeStructure->size() : 0);
  }
 
  template <typename T>
  static TBranch* remapBranch(TBranch& branchRef, T** newdata)
  {
    auto tree = branchRef.GetTree();
    auto name = branchRef.GetName();
    auto branch = tree->GetBranch(name); // the input branch might actually no belong to the tree but to TreeWriter cache
    assert(branch);
    if (branch->GetEntries()) { // if it has entries, then it was already remapped/filled at prevous event
      branch->SetAddress(newdata);
      return branch;
    }
    auto branchleaves = branch->GetListOfLeaves();
    branch->DropBaskets("all");
    branch->DeleteBaskets("all");
    tree->GetListOfBranches()->Remove(branch);
    for (auto entry : *branchleaves) {
      tree->GetListOfLeaves()->Remove(entry);
    }
    // ROOT leaves holes in the arrays so we need to compress as well
    tree->GetListOfBranches()->Compress();
    tree->GetListOfLeaves()->Compress();
    // create a new branch with the same original name but attached to the new data
    return tree->Branch(name, newdata);
  }
 
 private:
  struct BranchSpec {
    std::vector<key_type> keys;
    std::vector<std::string> names;
    std::vector<TBranch*> branches;
    TClass* classinfo = nullptr;
    IndexExtractor getIndex = nullptr;
    BranchNameMapper getName = nullptr;
  };
 
  using InputContext = InputRecord;
 
  class TreeStructureInterface
  {
   public:
    static const size_t STAGE = 0;
    TreeStructureInterface() = default;
    virtual ~TreeStructureInterface() = default;
 
    virtual void setup(std::vector<BranchSpec>&, TTree*) {}
    virtual void exec(InputContext&, std::vector<BranchSpec>&) {}
    virtual size_t size() const { return STAGE; }
 
    // a dummy method called in the recursive processing
    void setupInstance(std::vector<BranchSpec>&, TTree*) {}
    // a dummy method called in the recursive processing
    void process(InputContext&, std::vector<BranchSpec>&) {}
  };
 
  template <typename T = char>
  using BinaryBranchStoreType = std::tuple<std::vector<T>, TBranch*, size_t>;
 
  // type trait to determine the type of the storage
  // the storage type is different depending on the type, because
  // - binary branches are supported
  // - the ROOT TTree API makes a difference between fundamental types where the pointer to variable is
  //   passed and complex objects with dictionary where the pointer to a pointer variable needs to be
  //   passed. The former case will allways include a copy of the value, the latter uses the deserialized
  //   object by pointer
  // It appears, that also vectors of fundamental and also messageable tyapes can be treated in the same
  // way as fundamental types, as long as there is a corresponding TClass implementation. ROOT creates those
  // for vectors of fundamental types, for all other types, ClassDefNV macro is needed in the class
  // declaration together with entry in LinkDef.
  template <typename T, typename _ = void>
  struct StructureElementTypeTrait {
  };
 
  using BinaryBranchSpecialization = std::integral_constant<char, 0>;
  using MessageableTypeSpecialization = std::integral_constant<char, 1>;
  using MessageableVectorSpecialization = std::integral_constant<char, 2>;
  using ROOTTypeSpecialization = std::integral_constant<char, 3>;
 
  // the binary branch format is chosen for const char*
  // using internally a vector<char>, this involves for the moment a copy, investigate if ROOT
  // can write a simple array of chars and use a pointer
  template <typename T>
  struct StructureElementTypeTrait<T, std::enable_if_t<std::is_same<T, const char*>::value>> {
    using value_type = T;
    using store_type = BinaryBranchStoreType<char>;
    using specialization_id = BinaryBranchSpecialization;
  };
 
  // all messageable types
  // using an internal variable of the given type, involves a copy
  template <typename T>
  struct StructureElementTypeTrait<T, std::enable_if_t<is_messageable<T>::value>> {
    using value_type = T;
    using store_type = value_type;
    using specialization_id = MessageableTypeSpecialization;
  };
 
  // vectors of messageable types
  template <typename T>
  struct StructureElementTypeTrait<T, std::enable_if_t<has_messageable_value_type<T>::value &&
                                                       is_specialization_v<T, std::vector>>> {
    using value_type = T;
    using store_type = value_type*;
    using specialization_id = MessageableVectorSpecialization;
  };
 
  // types with root dictionary but non-messageable and not vectors of messageable type
  template <typename T>
  struct StructureElementTypeTrait<T, std::enable_if_t<has_root_dictionary<T>::value &&
                                                       is_messageable<T>::value == false &&
                                                       has_messageable_value_type<T>::value == false>> {
    using value_type = T;
    using store_type = value_type*;
    using specialization_id = ROOTTypeSpecialization;
  };
 
  // types marked as ROOT serialized
  template <typename T>
  struct StructureElementTypeTrait<T,
                                   std::enable_if_t<is_specialization_v<T, ROOTSerialized> == true>> {
    using value_type = typename T::wrapped_type;
    using store_type = value_type*;
    using specialization_id = ROOTTypeSpecialization;
  };
 
  template <typename DataT, typename BASE>
  class TreeStructureElement : public BASE
  {
   public:
    using PrevT = BASE;
    using value_type = typename StructureElementTypeTrait<DataT>::value_type;
    using store_type = typename StructureElementTypeTrait<DataT>::store_type;
    using specialization_id = typename StructureElementTypeTrait<DataT>::specialization_id;
    static const size_t STAGE = BASE::STAGE + 1;
    TreeStructureElement() = default;
    ~TreeStructureElement() override = default;
 
    void setup(std::vector<BranchSpec>& specs, TTree* tree) override
    {
      setupInstance(specs, tree);
    }
 
    // this is the polymorphic entry point for processing of branch specs
    // recursive processing starting from the highest instance
    void exec(InputContext& context, std::vector<BranchSpec>& specs) override
    {
      process(context, specs);
    }
    size_t size() const override { return STAGE; }
 
    // the default method creates branch using address to store variable
    // Note: the type of the store variable is pointer to object for objects with a ROOT TClass
    // interface, or plain type for all others
    // specialized on specialization_id
    template <typename S, typename std::enable_if_t<!std::is_same<S, BinaryBranchSpecialization>::value, int> = 0>
    TBranch* createBranch(TTree* tree, const char* name, size_t branchIdx)
    {
      return tree->Branch(name, &(mStore.at(branchIdx)));
    }
 
    // specialization for binary buffers indicated by const char*
    // a variable binary data branch is written, the size of each entry is stored in a size branch
    // specialized on specialization_id
    template <typename S, typename std::enable_if_t<std::is_same<S, BinaryBranchSpecialization>::value, int> = 0>
    TBranch* createBranch(TTree* tree, const char* name, size_t branchIdx)
    {
      // size variable to write the size of the data branch
      std::get<2>(mStore.at(branchIdx)) = 1;
      // branch name of the size branch
      std::string sizeBranchName = std::string(name) + "Size";
      // leaf list: one leaf of type unsinged int
      std::string leafList = sizeBranchName + "/i";
      std::get<1>(mStore.at(branchIdx)) = tree->Branch(sizeBranchName.c_str(), &(std::get<2>(mStore.at(branchIdx))), leafList.c_str());
      return tree->Branch(name, &(std::get<0>(mStore.at(branchIdx))));
    }
 
    void setupInstance(std::vector<BranchSpec>& specs, TTree* tree)
    {
      // recursing through the tree structure by simply using method of the previous type,
      // i.e. the base class method.
      PrevT::setupInstance(specs, tree);
      constexpr size_t SpecIndex = STAGE - 1;
      if (specs[SpecIndex].branches.size() == 0) {
        // this definition is disabled
        return;
      }
      specs[SpecIndex].classinfo = TClass::GetClass(typeid(value_type));
      if (std::is_same<value_type, const char*>::value == false && std::is_fundamental<value_type>::value == false &&
          specs[SpecIndex].classinfo == nullptr) {
        // for all non-fundamental types but the special case for binary chunks, a dictionary is required
        // FIXME: find a reliable way to check that the type has been specified in the LinkDef
        // Only then the required functionality for streaming the type to the branch is available.
        // If e.g. a standard container of some ROOT serializable type has not been specified in
        // LinkDef, the functionality is not available and the attempt to stream will simply crash.
        // Unfortunately, a class info object can be extracted for the type, so this check does not help
        throw std::runtime_error(std::to_string(SpecIndex) + ": no dictionary available for non-fundamental type " + typeid(value_type).name());
      }
      size_t branchIdx = 0;
      mStore.resize(specs[SpecIndex].names.size());
      for (auto const& name : specs[SpecIndex].names) {
        specs[SpecIndex].branches.at(branchIdx) = createBranch<specialization_id>(tree, name.c_str(), branchIdx);
        if (specs[SpecIndex].branches.at(branchIdx) == nullptr) {
          throw std::runtime_error(std::to_string(SpecIndex) + ": can not create branch " + name + " for type " + typeid(value_type).name() + " - LinkDef entry missing?");
        }
        LOG(info) << SpecIndex << ": branch  " << name << " set up";
        branchIdx++;
      }
    }
 
    template <typename DataType>
    bool runCallback(TBranch* branch, DataType const& data, DataRef const& ref)
    {
      if (std::holds_alternative<typename BranchDef<value_type>::Spectator>(mCallback)) {
        std::get<typename BranchDef<value_type>::Spectator>(mCallback)(data);
      }
      if (std::holds_alternative<typename BranchDef<value_type>::SpectatorExt>(mCallback)) {
        std::get<typename BranchDef<value_type>::SpectatorExt>(mCallback)(data, ref);
      }
      if (std::holds_alternative<typename BranchDef<value_type>::Fill>(mCallback)) {
        std::get<typename BranchDef<value_type>::Fill>(mCallback)(*branch, data);
        return true;
      }
      if (std::holds_alternative<typename BranchDef<value_type>::FillExt>(mCallback)) {
        std::get<typename BranchDef<value_type>::FillExt>(mCallback)(*branch, data, ref);
        return true;
      }
      return false;
    }
 
    // specialization for trivial structs or serialized objects without a TClass interface
    // the extracted object is copied to store variable
    template <typename S, typename std::enable_if_t<std::is_same<S, MessageableTypeSpecialization>::value, int> = 0>
    void fillData(InputContext& context, DataRef const& ref, TBranch* branch, size_t branchIdx)
    {
      auto data = context.get<value_type>(ref);
      if (!runCallback(branch, data, ref)) {
        mStore[branchIdx] = data;
        branch->Fill();
      }
    }
 
    // specialization for non-messageable types with ROOT dictionary
    // for non-trivial structs, the address of the pointer to the objects needs to be used
    // in order to directly use the pointer to extracted object
    // store is a pointer to object
    template <typename S, typename std::enable_if_t<std::is_same<S, ROOTTypeSpecialization>::value, int> = 0>
    void fillData(InputContext& context, DataRef const& ref, TBranch* branch, size_t branchIdx)
    {
      auto data = context.get<typename std::add_pointer<value_type>::type>(ref);
      if (!runCallback(branch, *data, ref)) {
        // this is ugly but necessary because of the TTree API does not allow a const
        // object as input. Have to rely on that ROOT treats the object as const
        mStore[branchIdx] = const_cast<value_type*>(data.get());
        branch->Fill();
      }
    }
 
    // specialization for binary buffers using const char*
    // this writes both the data branch and a size branch
    template <typename S, typename std::enable_if_t<std::is_same<S, BinaryBranchSpecialization>::value, int> = 0>
    void fillData(InputContext& context, DataRef const& ref, TBranch* branch, size_t branchIdx)
    {
      auto data = context.get<gsl::span<char>>(ref);
      std::get<2>(mStore.at(branchIdx)) = data.size();
      std::get<1>(mStore.at(branchIdx))->Fill();
      std::get<0>(mStore.at(branchIdx)).resize(data.size());
      memcpy(std::get<0>(mStore.at(branchIdx)).data(), data.data(), data.size());
      branch->Fill();
    }
 
    // specialization for vectors of messageable types
    template <typename S, typename std::enable_if_t<std::is_same<S, MessageableVectorSpecialization>::value, int> = 0>
    void fillData(InputContext& context, DataRef const& ref, TBranch* branch, size_t branchIdx)
    {
      using ElementType = typename value_type::value_type;
      static_assert(is_messageable<ElementType>::value, "logical error: should be correctly selected by StructureElementTypeTrait");
 
      // A helper struct mimicking data layout of std::vector containers
      // We assume a standard layout of begin, end, end_capacity
      struct VecBase {
        VecBase() = default;
        const ElementType* start = nullptr;
        const ElementType* end = nullptr;
        const ElementType* cap = nullptr;
      };
 
      // a low level hack to make a gsl::span appear as a std::vector so that ROOT serializes the correct type
      // but without the need for an extra copy
      auto adopt = [](auto const& data, value_type& v) {
        static_assert(sizeof(v) == 24);
        if (data.size() == 0) {
          return;
        }
        VecBase impl;
        impl.start = &(data[0]);
        impl.end = &(data[data.size() - 1]) + 1; // end pointer (beyond last element)
        impl.cap = impl.end;
        std::memcpy(&v, &impl, sizeof(VecBase));
      };
 
      // if the value type is messagable and has a ROOT dictionary, two serialization methods are possible
      // for the moment, the InputRecord API can not handle both with the same call
      try {
        // try extracting from message with serialization method NONE, throw runtime error
        // if message is serialized
        auto data = context.get<gsl::span<ElementType>>(ref);
        // take an ordinary std::vector "view" on the data
        auto* dataview = new value_type;
        adopt(data, *dataview);
        if (!runCallback(branch, *dataview, ref)) {
          mStore[branchIdx] = dataview;
          branch->Fill();
        }
        // we delete JUST the view without deleting the data (which is handled by DPL)
        auto ptr = (VecBase*)dataview;
        if (ptr) {
          delete ptr;
        }
      } catch (RuntimeErrorRef e) {
        if constexpr (has_root_dictionary<value_type>::value == true) {
          // try extracting from message with serialization method ROOT
          auto data = context.get<typename std::add_pointer<value_type>::type>(ref);
          if (!runCallback(branch, *data, ref)) {
            mStore[branchIdx] = const_cast<value_type*>(data.get());
            branch->Fill();
          }
        } else {
          // the type has no ROOT dictionary, re-throw exception
          throw e;
        }
      }
    }
 
    // process previous stage and this stage
    void process(InputContext& context, std::vector<BranchSpec>& specs)
    {
      // recursing through the tree structure by simply using method of the previous type,
      // i.e. the base class method.
      PrevT::process(context, specs);
      constexpr size_t SpecIndex = STAGE - 1;
      BranchSpec const& spec = specs[SpecIndex];
      if (spec.branches.size() == 0) {
        // this definition is disabled
        return;
      }
      // loop over all defined inputs
      for (auto const& key : spec.keys) {
        auto keypos = context.getPos(key.c_str());
        auto parts = context.getNofParts(keypos);
        for (decltype(parts) part = 0; part < parts; part++) {
          auto dataref = context.get(key.c_str(), part);
          size_t branchIdx = 0;
          if (spec.getIndex) {
            branchIdx = spec.getIndex(dataref);
            if (branchIdx == ~(size_t)0) {
              // this indicates skipping
              continue;
            }
          }
          fillData<specialization_id>(context, dataref, spec.branches.at(branchIdx), branchIdx);
        }
      }
    }
 
    // helper function to get Nth argument from the argument pack
    template <size_t N, typename Arg, typename... Args>
    auto getArg(Arg&& arg, Args&&... args)
    {
      if constexpr (N == 0) {
        return arg;
      } else if constexpr (sizeof...(Args) > 0) {
        return getArg<N - 1>(std::forward<Args>(args)...);
      }
    }
 
    // recursively set optional callback from argument pack and recurse to all folded types
    template <typename... Args>
    void setCallback(Args&&... args)
    {
      // recursing through the tree structure by simply using method of the previous type,
      // i.e. the base class method.
      if constexpr (STAGE > 1) {
        PrevT::setCallback(std::forward<Args>(args)...);
      }
 
      // now set this instance, the argument position is determined by the STAGE counter
      auto arg = getArg<STAGE - 1>(std::forward<Args>(args)...);
      if constexpr (std::is_same<value_type, typename decltype(arg)::type>::value) {
        if (not std::holds_alternative<std::monostate>(arg.callback)) {
          mCallback = std::move(arg.callback);
        }
      }
    }
 
   private:
    std::vector<store_type> mStore;
    typename BranchDef<value_type>::BranchCallback mCallback;
  };
 
  template <typename Arg, typename... Args>
  void parseConstructorArgs(Arg&& arg, Args&&... args)
  {
    using Type = std::decay_t<Arg>;
    if constexpr (can_assign<Type, CustomClose>::value) {
      mCustomClose = arg;
    } else {
      mTreeStructure = createTreeStructure<0, TreeStructureInterface>(std::forward<Arg>(arg), std::forward<Args>(args)...);
      return;
    }
    if constexpr (sizeof...(Args) > 0) {
      parseConstructorArgs(std::forward<Args>(args)...);
    }
  }
 
  template <size_t N, typename BASE, typename T, typename... Args>
  auto createTreeStructure(T&& def, Args&&... args)
  {
    // Note: a branch definition can be disabled by setting nofBranches to zero
    // an entry of the definition is kept in the registry, but the branches vector
    // is of size zero, which will make the writer to always skip this definition
    mBranchSpecs.push_back({{}, {def.branchName}});
    auto& spec = mBranchSpecs.back();
 
    // extract the internal keys for the list of provided input definitions
    size_t idx = 0;
    spec.keys.resize(def.keys.size());
    std::generate(spec.keys.begin(), spec.keys.end(), [&def, &idx] { return T::key_extractor::asString(def.keys[idx++]); });
    mBranchSpecs.back().branches.resize(def.nofBranches, nullptr);
    // a branch definition might be disabled by setting number of branches to 0; if enabled,
    // the number of branches has to match the number of inputs but can be larger depending
    // on the exact functionality provided with the getIndex callback. In any case, the
    // callbacks only need to be propagated if multiple branches are defined
    assert(def.nofBranches == 0 || def.nofBranches >= spec.keys.size());
    // a getIndex function makes only sense if there are multiple branches
    assert(def.nofBranches <= 1 || def.getIndex);
    if (def.nofBranches > 1) {
      // FIXME: should that be an exception since assert is disabled in the normal build?
      assert(def.getIndex && def.getName);
      mBranchSpecs.back().getIndex = def.getIndex;
      mBranchSpecs.back().names.resize(def.nofBranches);
    }
 
    // always amend the branch name(s) if the callback is configured
    if (def.getName) {
      mBranchSpecs.back().getName = def.getName;
      idx = 0;
      std::generate(mBranchSpecs.back().names.begin(), mBranchSpecs.back().names.end(),
                    [&def, &idx]() { return def.getName(def.branchName, idx++); });
    }
    using type = TreeStructureElement<typename T::type, BASE>;
    if constexpr (N == 0) {
      // in the upper most call we have the concrete type of the mixin object
      // and call its method to set the callbacks from the argument pack, it
      // recurses to all folded types
      auto instance = createTreeStructure<N + 1, type>(std::forward<Args>(args)...);
      instance->setCallback(std::move(def), std::forward<Args>(args)...);
      // the upper most call returns the unique pointer of the virtual interface
      std::unique_ptr<TreeStructureInterface> ret(instance.release());
      return ret;
    } else {
      return std::move(createTreeStructure<N + 1, type>(std::forward<Args>(args)...));
    }
  }
 
  // last iteration, returning unique pointer of the concrete mixin
  template <size_t N, typename T>
  std::unique_ptr<T> createTreeStructure()
  {
    static_assert(N > 0, "The writer does not make sense without branch definitions");
    return std::make_unique<T>();
  }
 
  std::unique_ptr<TFile> mFile;
  std::unique_ptr<TTree> mTree;
  std::vector<BranchSpec> mBranchSpecs;
  std::unique_ptr<TreeStructureInterface> mTreeStructure;
  bool mIsClosed = false;
  CustomClose mCustomClose;
};
 
} // namespace framework
} // namespace o2
#endif