KVTreeVectorBranchHandler.h

#pragma once
 
#include <vector>
#include <unordered_map>
#include "TTree.h"
 
class KVTreeVectorBranchHandler
{
   template<typename U>
   class my_vector
   {
      std::vector<U> _data;
      public:
      my_vector& operator=(const my_vector&) = delete;
      my_vector& operator=(my_vector&&) = delete;
      void operator=(U u)
      {
         _data.push_back(u);
      }
      std::vector<U>& get_vec_ref()
      {
         return _data;
      }
   };
   template<typename T>
   using particle_vector = std::unordered_map<std::string,my_vector<T>>;
   template<typename T>
   std::reference_wrapper<particle_vector<T>> get_vectors()
   {
      return std::ref(particle_vector<T>{});
   }
   template<typename T>
   void clear_all_vectors()
   {
      for(auto &v : get_vectors<T>().get())
      {
         v.second.get_vec_ref().clear();
      }
   }
   particle_vector<int> int_vectors;
   particle_vector<float> float_vectors;
   particle_vector<double> double_vectors;
 
   public:
 
   template<typename VarType>
   void AddVectorBranch(TTree* t, const std::string& var)
   {
      t->Branch(var.c_str(), &get_vectors<VarType>().get()[var].get_vec_ref());
   }
 
   void ClearVectorBranches()
   {
      clear_all_vectors<int>();
      clear_all_vectors<double>();
      clear_all_vectors<float>();
   }
   template<typename VarType>
   void FillVectorBranch(const std::string& var, VarType val)
   {
      get_vectors<VarType>().get()[var] = val;
   }
};
 
template<>
std::reference_wrapper<KVTreeVectorBranchHandler::particle_vector<int>>
inline KVTreeVectorBranchHandler::get_vectors<int>()
{
   return int_vectors;
}
template<>
std::reference_wrapper<KVTreeVectorBranchHandler::particle_vector<double>>
inline KVTreeVectorBranchHandler::get_vectors<double>()
{
   return double_vectors;
}
template<>
std::reference_wrapper<KVTreeVectorBranchHandler::particle_vector<float>>
inline KVTreeVectorBranchHandler::get_vectors<float>()
{
   return float_vectors;
}