ToolBinder.h

Go to the documentation of this file.

/*****************************************************************************\
* (c) Copyright 2021-2026 CERN for the benefit of the LHCb Collaboration      *
*                                                                             *
* This software is distributed under the terms of the GNU General Public      *
* Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
*                                                                             *
* In applying this licence, 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.                                       *
\*****************************************************************************/
#pragma once
#include "details.h"
#include "utilities.h"
#include <GaudiKernel/AlgTool.h>
#include <GaudiKernel/IBinder.h>
 
namespace Gaudi::Functional {
  namespace details {
    template <typename Signature, typename Traits>
    class ToolBinder;
 
    template <typename IFace, typename... Args, typename Traits>
    class ToolBinder<Gaudi::Interface::Bind::Box<IFace>( Args const&... ), Traits>
        : public extends<details::BaseClass_t<Traits, AlgTool>, Gaudi::Interface::Bind::IBinder<IFace>> {
 
    public:
      constexpr static std::size_t N = sizeof...( Args );
      using KeyValue                 = LocationSpec::KeyValue;
      using KeyValues                = LocationSpec::KeyValues;
      using InputSpecTuple           = LocationSpecs_t<Args...>;
      using InputSpecs               = LocationSpecs<InputSpecTuple>;
      using Creator                  = Gaudi::Interface::Bind::Box<IFace> ( * )( void const*, Args const&... );
 
      template <size_t... I>
      ToolBinder( std::string type, std::string name, const IInterface* parent, InputSpecTuple const& args,
                  Creator creator, std::index_sequence<I...> )
          : extends<details::BaseClass_t<Traits, AlgTool>, Gaudi::Interface::Bind::IBinder<IFace>>{ std::move( type ),
                                                                                                    std::move( name ),
                                                                                                    parent }
          , m_handles{ std::tuple_cat( std::forward_as_tuple( this ), std::get<I>( args ) )... }
          , m_creator{ creator } {}
 
    private:
      std::tuple<details::InputHandle_t<Traits, Args>...> m_handles;
      Creator                                             m_creator;
 
    public:
      ToolBinder( std::string type, std::string name, const IInterface* parent, InputSpecs const& inputs,
                  Creator creator )
          : ToolBinder{ std::move( type ), std::move( name ), parent,
                        inputs.tuple(),    creator,           std::make_index_sequence<N>{} } {}
 
      Gaudi::Interface::Bind::Box<IFace> bind( EventContext const& ctx ) const final {
        return std::apply(
            [&]( auto const&... arg ) {
              using namespace details;
              return std::invoke( m_creator, this, get( arg, *this, ctx )... );
            },
            m_handles );
      }
 
      template <std::size_t N = 0>
      decltype( auto ) inputLocation() const {
        using namespace details;
        return getKey( std::get<N>( m_handles ) );
      }
      template <typename T>
      decltype( auto ) inputLocation() const {
        using namespace details;
        return getKey( std::get<InputHandle_t<Traits, std::decay_t<T>>>( m_handles ) );
      }
 
      // TODO: make this a callable instance?
      template <typename BoundInstance, typename Self>
      static auto construct( Self* ) {
        static_assert( std::is_base_of_v<ToolBinder, Self> );
        return +[]( void const* ptr, const Args&... args ) {
          return Gaudi::Interface::Bind::Box<IFace>{ std::in_place_type<BoundInstance>,
                                                     static_cast<std::add_const_t<Self>*>( ptr ), args... };
        };
      }
    };
  } // namespace details
 
  template <typename Signature, typename Traits_ = Traits::use_<Traits::BaseClass_t<AlgTool>>>
  using ToolBinder = details::ToolBinder<Signature, Traits_>;
 
} // namespace Gaudi::Functional