EIC code displayed by LXR master/​include/​Geant4/​G4Profiler.icc	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:58:58

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 // G4Profiler
 //
 // Template definition file
 //
 // Author: Jonathan Madsen, LBNL - November 2020
 // --------------------------------------------------------------------
 
 #if !defined(G4PROFILER_ICC_)
 #  define G4PROFILER_ICC_ 1
 
 #  include <functional>
 #  include <type_traits>
 #  include <tuple>
 #  include <initializer_list>
 #  include <string>
 #  include <sstream>
 
 // for index_sequence implementation
 #  include "PTL/Globals.hh"
 
 #  if defined(GEANT4_USE_TIMEMORY)
 #    include <timemory/utility/utility.hpp>
 #  endif
 
 #  if !defined(GEANT4_FOLD_EXPRESSION)
 #    define GEANT4_FOLD_EXPRESSION(...)                                        \
       ::G4Impl::consume_parameters(                                            \
         ::std::initializer_list<int>{ (__VA_ARGS__, 0)... })
 #  endif
 
 #  if !defined(G4PROFILER_ARG_SET)
 #    define G4PROFILER_ARG_SET(...) G4TypeList<__VA_ARGS__>
 #  endif
 
 //----------------------------------------------------------------------------//
 // lightweight (w.r.t. compile-time) alternative to std::tuple that doesn't
 // store anything and cannot be instantiated because it has no definition. This
 // guards against meta-programming mistakes where:
 //    std::function<void(const G4Step*)>
 // ends up as
 //    std::function<void(G4TypeList<const G4Step*>)>
 template <typename... Types>
 struct G4TypeList;
 
 // this is used in G4Impl::Functors to add a common set of arguments to all of
 // the functors
 template <typename... Types>
 struct G4CommonTypeList;
 
 //--------------------------------------------------------------------------------------//
 //
 template <typename... Types>
 struct G4TypeListSize;
 
 template <typename... Types>
 struct G4TypeListSize<G4TypeList<Types...>>
 {
   static constexpr size_t value = sizeof...(Types);
 };
 
 template <typename... Types>
 struct G4TypeListSize<std::tuple<Types...>>
 {
   static constexpr size_t value = std::tuple_size<std::tuple<Types...>>::value;
 };
 
 namespace G4Impl
 {
   template <typename Tp>
   std::string demangle()
   {
 #  if defined(GEANT4_USE_TIMEMORY)
     return tim::demangle<Tp>();
 #  else
     return typeid(Tp).name();
 #  endif
   }
 
   template <typename... Tp>
   void consume_parameters(Tp&&...)
   {}
   //------------------------------------------------------------------------//
   // don't provide a definition that works without G4TypeList
   template <typename RetT, typename... Tail>
   struct Functors;
   //------------------------------------------------------------------------//
   template <typename RetT, typename... Tail>
   struct Functors<RetT, G4TypeList<Tail...>>
   {
     using type = std::function<RetT(Tail...)>;
   };
   //------------------------------------------------------------------------//
   template <typename RetT, typename... CommonT, typename... Tail>
   struct Functors<RetT, G4CommonTypeList<CommonT...>, G4TypeList<Tail...>>
   {
     using type = std::function<RetT(CommonT..., Tail...)>;
   };
   //------------------------------------------------------------------------//
   template <typename RetT, typename... Types, typename... Tail>
   struct Functors<RetT, G4TypeList<G4TypeList<Types...>, Tail...>>
   {
     using type = std::tuple<std::function<RetT(Types...)>,
                             typename Functors<RetT, Tail>::type...>;
   };
   //------------------------------------------------------------------------//
   template <typename RetT, typename... CommonT, typename... Types,
             typename... Tail>
   struct Functors<RetT, G4CommonTypeList<CommonT...>,
                   G4TypeList<G4TypeList<Types...>, Tail...>>
   {
     using type = std::tuple<
       std::function<RetT(CommonT..., Types...)>,
       typename Functors<RetT, G4CommonTypeList<CommonT...>, Tail>::type...>;
   };
   //------------------------------------------------------------------------//
   template <typename RetT, typename... Tail>
   using Functors_t = typename Functors<RetT, Tail...>::type;
 
 }  // namespace G4Impl
 
 //
 //  this allows the generic invocation or assignment of a functor
 //
 template <typename Type, typename FuncT, typename RetT = void>
 struct FuncHandler
 {
   using this_type = FuncHandler<Type, FuncT, RetT>;
 
   // until Geant4 updates to C++14 as a minimum
   template <typename Tp>
   using decay_t = typename std::decay<Tp>::type;
   template <bool Bv, typename Tp = void>
   using enable_if_t = typename std::enable_if<Bv, Tp>::type;
   template <size_t... Idx>
   using index_sequence = PTL::mpl::index_sequence<Idx...>;
   template <size_t NumT>
   using make_index_sequence = PTL::mpl::make_index_sequence<NumT>;
 
   static constexpr size_t size = std::tuple_size<FuncT>::value;
 
   FuncHandler(FuncT& _functors)
     : m_functors(_functors)
   {}
 
   // overloading the assignment operator will let users
   // be able to use one method for the G4ProfilerConfig
   // despite the potential variants. Thus this is valid:
   //
   // GetLabelFunctor() = [](int i) { return std::to_string(i); }
   // GetLabelFunctor() = [](float v) { return std::to_string(v); }
   //
   // but will only compile for types that are explicitly
   // supported --> the assign function iterates through the
   // specific variants at compile-time
   template <typename Func>
   void operator=(Func&& f)
   {
     assign(m_functors, std::forward<Func>(f), 0, make_index_sequence<size>{});
   }
 
  private:
   FuncT& m_functors;
 
   template <typename Tp>
   static enable_if_t<std::is_same<decay_t<Tp>, bool>::value, Tp>
   get_default_return_value()
   {
     return false;
   }
 
   template <typename Tp>
   static enable_if_t<std::is_same<decay_t<Tp>, std::string>::value, Tp>
   get_default_return_value()
   {
     // this may return an ugly mangled name but will at least but useful
     // and can be demangled with c++filt
     return std::string("label-functor-not-set-for-") + G4Impl::demangle<Tp>();
   }
 
   template <typename Tp>
   static enable_if_t<std::is_pointer<decay_t<Tp>>::value, Tp>
   get_default_return_value()
   {
     return nullptr;
   }
 
  private:
   using return_t = decay_t<RetT>;
 
   //
   //  NOTE: All references to "iterations" in the comments
   //  below refer to compile-time iterations, which are
   //  implemented through recusion below. Iterations stop
   //  when a valid statement has been found and thus necessitates
   //  four versions of the same function: two of these functions
   //  handle the end of the recursion 'sizeof...(Tail) == 0'
   //  and the first of these functions (1.a) is used if a valid
   //  statement is found and the second (1.b, if reached) introduces
   //  a compilation error. The third and fourth start the iteration
   //  when 'sizeof...(Tail) > 0'. If a valid statement is found
   //  in the third function (2.a), recursion stops. If not, the
   //  iteration is continued to the next index via the fourth
   //  function (2.b).
   //
 
   // INVOKE 1.a
   //
   // this is the end of the iteration through the potential
   // functor variants and the trailing '->' tests whether the
   // functor can be called with the given arguments. The
   // 'int' as the second parameter ensures (through overload
   // resolution rules) that this gets tested before the
   // function after this (1.b).
   // If the size of 'FuncT' is equal to 1, then this is also
   // the start of the iteration through the potential functor
   // variants.
   template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
             enable_if_t<sizeof...(Tail) == 0, int> = 0>
   static auto invoke(Tp& _obj, int, index_sequence<Idx, Tail...>,
                      Args&&... _args)
     -> decltype(std::get<Idx>(_obj)(std::forward<Args>(_args)...), return_t{})
   {
     // if the functor has been set, then execute it
     if(std::get<Idx>(_obj))
       return std::get<Idx>(_obj)(std::forward<Args>(_args)...);
     else
     {
       std::stringstream ss;
       ss << "Error! Functor "
          << G4Impl::demangle<decltype(std::get<Idx>(_obj))>()
          << " was not set for " << G4Impl::demangle<Type>();
       throw std::runtime_error(ss.str());
     }
     // the default for booleans should return false
     return get_default_return_value<return_t>();
   }
 
   // INVOKE 1.b
   //
   // this is the end of the iteration through the potential
   // functor variants and if this function is reached during
   // compile-time, this means that the given arguments are
   // not supported by any of the functors and will fail to
   // compile. The 'long' as the second parameter ensures that
   // it has lower precedence than the one above
   template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
             enable_if_t<sizeof...(Tail) == 0, int> = 0>
   static auto invoke(Tp&, long, index_sequence<Idx, Tail...>, Args&&...)
     -> return_t
   {
     // this will cause a failure at compile-time.
     // this ensures that this static assert is dependent
     // on this function getting instantiated, simply putting
     // 'false' here would result in compile-time failure
     // even if no code ever instantiated this function
     static_assert(!std::is_same<Tp, Tp>::value, "Error! No valid functor!");
     throw std::runtime_error(
       "Error! No valid functor! This should have caused a compilation error!");
     return return_t{};
   }
 
   // INVOKE 2.a
   //
   // If the size of 'FuncT' is greater than one, this is the
   // start of the iteration through the potential functor variants.
   // This version will be used if the X in '-> decltype(X, Y)'
   // is valid. If it is not valid, then overload resolution
   // rules will dictate that the compiler will move on to the
   // 'invoke' member function 2.b
   template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
             enable_if_t<(sizeof...(Tail) > 0), int> = 0>
   static auto invoke(Tp& _obj, int, index_sequence<Idx, Tail...>,
                      Args&&... _args)
     -> decltype(std::get<Idx>(_obj)(std::forward<Args>(_args)...), return_t{})
   {
     return std::get<Idx>(_obj)(std::forward<Args>(_args)...);
   }
 
   // INVOKE 2.b
   //
   // If the above test was not valid, we discard the current index
   // ('Idx') and proceed to the next index. If there is only
   // one index remaining, then this will call proceed to the
   // first invoke member function (1.a). If there are multiple
   // indexes remaining, then this will proceed to the previous
   // invoke member function (2.a) and this will continue until
   // a valid match is found or will fail to compile.
   template <typename Tp, size_t Idx, size_t... Tail, typename... Args,
             enable_if_t<(sizeof...(Tail) > 0), int> = 0>
   static auto invoke(Tp& _obj, long, index_sequence<Idx, Tail...>,
                      Args&&... _args)
     -> decltype(invoke(_obj, 0, index_sequence<Tail...>{},
                        std::forward<Args>(_args)...))
   {
     return invoke(_obj, 0, index_sequence<Tail...>{},
                   std::forward<Args>(_args)...);
   }
 
  private:
   // this uses the same principles as the invoke member function.
   // See the comments there.
   template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
             enable_if_t<sizeof...(Tail) == 0, int> = 0>
   static auto assign(LhsT& _lhs, RhsT&& _rhs, int, index_sequence<Idx, Tail...>)
     -> decltype((std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs)), void())
   {
     std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs);
   }
 
   // this uses the same principles as the invoke member function.
   // See the comments there.
   template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
             enable_if_t<sizeof...(Tail) == 0, int> = 0>
   static void assign(LhsT&, RhsT&&, long, index_sequence<Idx, Tail...>)
   {
     // this will cause a failure at compile-time.
     // this ensures that this static assert is dependent
     // on this function getting instantiated, simply putting
     // 'false' here would result in compile-time failure
     // even if no code ever instantiated this function
     static_assert(!std::is_same<LhsT, LhsT>::value,
                   "Error! No valid functor assignment!");
     throw std::runtime_error(
       "Error! No valid functor! This should have caused a compilation error!");
   }
 
   // this uses the same principles as the invoke member function.
   // See the comments there.
   template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
             enable_if_t<(sizeof...(Tail) > 0), int> = 0>
   static auto assign(LhsT& _lhs, RhsT&& _rhs, int, index_sequence<Idx, Tail...>)
     -> decltype((std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs)), void())
   {
     std::get<Idx>(_lhs) = std::forward<RhsT>(_rhs);
   }
 
   // this uses the same principles as the invoke member function.
   // See the comments there.
   template <typename LhsT, typename RhsT, size_t Idx, size_t... Tail,
             enable_if_t<(sizeof...(Tail) > 0), int> = 0>
   static void assign(LhsT& _lhs, RhsT&& _rhs, long,
                      index_sequence<Idx, Tail...>)
   {
     assign(_lhs, std::forward<RhsT>(_rhs), 0, index_sequence<Tail...>{});
   }
 
  public:
   // overloading the call operator makes it generic to call
   // the functors but will only compile for types that are
   // explicitly supported --> the invoke function iterates
   // through the specific variants at compile-time to
   // ensure using SFINAE
   template <typename... Args>
   auto operator()(Args&&... _args)
     -> decltype(std::declval<this_type>().invoke(std::declval<FuncT&>(), 0,
                                                  make_index_sequence<size>{},
                                                  std::forward<Args>(_args)...))
   {
     return invoke(m_functors, 0, make_index_sequence<size>{},
                   std::forward<Args>(_args)...);
   }
 };
 
 //----------------------------------------------------------------------------//
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team