ClingCallWrapper.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
  */
#pragma once
#include <type_traits>
#include <array>
#include <string>
#include <sstream>
#include <stdexcept>
 
#include "TClass.h"
#include "TMethod.h"
#include "TROOT.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"
#include "TGenericClassInfo.h"
 
#include "CxxUtils/checker_macros.h"
 
namespace RootUtils {
template<typename T>
constexpr auto getPtr(typename std::remove_reference<T>::type& arg) noexcept {
   // the interface requires that the argument list is a list of non-const void pointers
   // It is assumed that the argument types have been checked before hand.
   auto non_const_arg ATLAS_THREAD_SAFE = const_cast<std::remove_cvref<T>::type *>( &arg);
   return non_const_arg;
}
 
template <typename ...T_MethodArgs>
class ClingCallWrapperUncheckedReturnValue;
template <typename T_ReturnValue, typename ...T_MethodArgs>
class ClingCallWrapper;
 
template <typename ...T_MethodArgs>
ClingCallWrapperUncheckedReturnValue<T_MethodArgs...> getClingCallWrapper(TClass *the_class, const std::string &method_name, bool is_const);
 
template <typename T_ReturnValue, typename ...T_MethodArgs>
ClingCallWrapper<T_ReturnValue, T_MethodArgs...> getClingCallWrapperChecked(ClingCallWrapperUncheckedReturnValue<T_MethodArgs...> &&call_wrapper);

// @TODO add access policy to also handle non-const methods securely
template <typename ...T_MethodArgs>
class ClingCallWrapperUncheckedReturnValue {
   template<typename ...T_MethodArgsFunc>
   friend ClingCallWrapperUncheckedReturnValue<T_MethodArgsFunc...> getClingCallWrapper(TClass *the_class, const std::string &method_name, bool is_const);
 
   template <typename T_ReturnValue, typename ...T_MethodArgsFunc>
   friend ClingCallWrapper<T_ReturnValue, T_MethodArgsFunc...> getClingCallWrapperChecked(ClingCallWrapperUncheckedReturnValue<T_MethodArgsFunc...> &&call_wrapper);
 
protected:
   // @brief The function prototype of the function returned by TMethod::InterfaceMethod:
   // @param obj pointer to the object.
   // @param nargs number of method arguments (excluding the this pointer).
   // @param arg_list array of void pointers, pointing to each of the nargs arguments.
   // @param ret_val pointer where the return value is to be stored.
   using TClingCallFuncWrapper_t = void (*)(void* /*obj*/, int /* nargs*/, void** /*arg_list*/, void* /*ret_val*/);
 
   ClingCallWrapperUncheckedReturnValue(TClingCallFuncWrapper_t method_wrapper, const TMethod *method)
      : m_methodWrapper(method_wrapper),
        m_method(method) {}
 
   template<typename T_ReturnType>
   T_ReturnType call(const void *object, T_MethodArgs...args) const {
      T_ReturnType return_value;
      std::array<void *, sizeof...(args)> arg_list{getPtr<T_MethodArgs>(args)...};
 
      // it was already checked that the method is declared const
      // the interface however requires a non const void pointer to the object independent of
      // of the method being const or non-const.
      void *non_const_obj ATLAS_THREAD_SAFE=const_cast<void *>(object);
      m_methodWrapper(non_const_obj, arg_list.size(),arg_list.data(),&return_value);
      return return_value;
   }
public:
   template<typename T_ReturnType>
   bool isReturnTypeMatching() const {
      return ROOT::Internal::GetDemangledTypeName(typeid(T_ReturnType)) == m_method->GetReturnTypeNormalizedName();
   }

   std::string getReturnTypeNormalizedName() const {
      return m_method->GetReturnTypeNormalizedName();
   }
private:
   TClingCallFuncWrapper_t m_methodWrapper = nullptr;
   const TMethod *m_method = nullptr;
   TMethodCall::EReturnType m_returnType;
};

template <typename T_ReturnValue, typename ...T_MethodArgs>
class ClingCallWrapper :  ClingCallWrapperUncheckedReturnValue<T_MethodArgs...>
{
template <typename T_ReturnValueFunc, typename ...T_MethodArgsFunc>
friend ClingCallWrapper<T_ReturnValueFunc, T_MethodArgsFunc...> getClingCallWrapperChecked(ClingCallWrapperUncheckedReturnValue<T_MethodArgsFunc...> &&call_wrapper);
 
protected:
   ClingCallWrapper(ClingCallWrapperUncheckedReturnValue<T_MethodArgs...> &&call_wrapper)
      : ClingCallWrapperUncheckedReturnValue<T_MethodArgs...>(std::move(call_wrapper))
   {}

   ClingCallWrapper(const ClingCallWrapperUncheckedReturnValue<T_MethodArgs...> &call_wrapper)
      : ClingCallWrapperUncheckedReturnValue<T_MethodArgs...>(call_wrapper)
   {}
public:
   //        was used the create this wrapper, the result will be undefined.
   T_ReturnValue operator()(const void *object, T_MethodArgs...args) const {
      return this->template call<T_ReturnValue>(object, args...);
   }
};

template <typename ...T_MethodArgs>
struct ArgGen {
static std::string addArgumentPrototype(std::string &arg_proto_type);
};
 
// specialization for an empty argument list.
template <>
struct ArgGen<> {
static std::string addArgumentPrototype([[maybe_unused]] std::string &arg_proto_type) {
   return std::string();
}
};
 
// implementation for an non-empty argument list.
template <typename T_First, typename ...T_MethodArgs>
struct ArgGen<T_First, T_MethodArgs...> {
static void  addArgumentPrototype(std::string &arg_proto_type) {
   if (!arg_proto_type.empty()) {
      arg_proto_type+=",";
   }
   else {
      constexpr unsigned int avTypeNameLength = 20;
      arg_proto_type.reserve(sizeof...(T_MethodArgs) * avTypeNameLength);
   }
   arg_proto_type += ROOT::Internal::GetDemangledTypeName(typeid(T_First));
   ArgGen<T_MethodArgs...>::addArgumentPrototype(arg_proto_type);
}
};

template <typename ...T_MethodArgs>
std::string makeArgumentPrototype() {
   std::string ret;
   ArgGen<T_MethodArgs...>::addArgumentPrototype(ret);
   return ret;
}

template <typename ...T_MethodArgs>
ClingCallWrapperUncheckedReturnValue<T_MethodArgs...> getClingCallWrapper(TClass *the_class, const std::string &method_name, bool is_const) {
   R__LOCKGUARD(gROOTMutex);
   const TMethod *method = the_class->GetMethodWithPrototype(method_name.c_str(),
                                                             makeArgumentPrototype<T_MethodArgs...>().c_str(),
                                                             is_const,
                                                             ROOT::kConversionMatch);
   if (!method) {
      std::stringstream amsg; amsg << "Failed to get method " << method_name << "(" << makeArgumentPrototype<T_MethodArgs...>() << ").";
      throw std::runtime_error(amsg.str());
   }
   MethodInfo_t *method_info=gInterpreter->MethodInfo_Factory(method->GetDeclId());
   static constexpr unsigned int flags = (kIsStatic|kIsPublic);
   unsigned int method_properties = gInterpreter->MethodInfo_Property(method_info);
   if ( (method_properties &  flags) != kIsPublic ) {
      std::runtime_error("Method is not public or is static.");
   }
   if (is_const && (method_properties & kIsConstant) != kIsConstant) {
      std::runtime_error("Method is not constant.");
   }
   using TheClingCallWrapper_t = ClingCallWrapperUncheckedReturnValue<T_MethodArgs...>;
 
   return TheClingCallWrapper_t(reinterpret_cast<TheClingCallWrapper_t::TClingCallFuncWrapper_t>(method->InterfaceMethod()),method);
}

template <typename T_ReturnValue, typename ...T_MethodArgs>
ClingCallWrapper<T_ReturnValue, T_MethodArgs...> getClingCallWrapperChecked(ClingCallWrapperUncheckedReturnValue<T_MethodArgs...> &&call_wrapper) {
   if (!call_wrapper.template isReturnTypeMatching<T_ReturnValue>()) {
      std::stringstream amsg;
      amsg << "Return type mismatch. Desired "
           << ROOT::Internal::GetDemangledTypeName(typeid(T_ReturnValue))
           << " != is " << call_wrapper.getReturnTypeNormalizedName();
      throw std::runtime_error(amsg.str());
   }
   return ClingCallWrapper<T_ReturnValue, T_MethodArgs...>(std::forward<decltype(call_wrapper)>(call_wrapper));
}
}