The Gaudi Framework  master (bb95dfce)
Loading...
Searching...
No Matches
Gaudi::Functional::details Namespace Reference

Namespaces

namespace  details2
namespace  detail2
namespace  zip

Classes

struct  Consumer
struct  Consumer< void(const In &...), Traits_, true >
struct  Consumer< void(const In &...), Traits_, false >
struct  type_list
class  DataHandleMixin
class  DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >
class  HandleVector
struct  invoke_optionally_t
struct  insert_t
struct  deref_t
class  vector_of_const_
struct  vector_of_output_
struct  vector_of_input_
struct  handle_vector_input
struct  handle_vector_input< vector_of_const_< T > >
struct  EventContextHandle
struct  LocationSpec
struct  LocationSpecFor
struct  LocationSpecFor< EventContext >
struct  LocationSpecFor< vector_of_input_< T > >
struct  LocationSpecFor< vector_of_output_< T > >
struct  TailLocationSpecs
struct  TailLocationSpecs< First, Rest... >
struct  first_or_empty
struct  first_or_empty< std::tuple< First, Rest... > >
class  LocationSpecs
class  DataHandleMixin< type_list< Out... >, type_list< In... >, Traits_ >
class  DataHandleMixin< type_list< void >, InputSpec, Traits_ >
struct  FilterPredicate
struct  FilterPredicate< bool(const In &...), Traits_, true >
struct  FilterPredicate< bool(const In &...), Traits_, false >
struct  MergingTransformer
struct  MergingTransformer< Out(const Args &...), Traits_, true >
struct  MergingTransformer< Out(const Args &...), Traits_, false >
struct  Producer
struct  SplittingMergingTransformer
struct  SplittingMergingTransformer< vector_of_< Out >(const Args &...), Traits_ >
struct  SplittingTransformer
struct  SplittingTransformer< vector_of_< Out >(const In &...), Traits_ >
class  ToolBinder
class  ToolBinder< Gaudi::Interface::Bind::Box< IFace >(Args const &...), Traits >

Concepts

concept  is_optional
concept  has_handle_vector_input
concept  location_vector_handle
concept  is_void_fun

Typedefs

template<typename T>
using remove_optional_t = typename details2::value_type_of<T>::type
template<typename Value, auto N>
using RepeatValues_ = decltype( get_values_helper<Value>( std::make_index_sequence<N>() ) )
template<typename Arg>
using handle_vector_input_t = typename handle_vector_input<Arg>::type
template<typename Tr, typename Default = Gaudi::Algorithm>
using BaseClass_t = detail2::BaseClass<Tr, Default>::type
template<typename Tr, typename T>
using OutputHandle_t = typename detail2::OutputHandle<T, Tr, DataObjectWriteHandle>::type
template<typename Tr, typename T>
using InputHandle_t = typename detail2::InputHandle<T, Tr, detail2::DefaultInputHandle_t>::type
template<typename Arg>
using LocationSpec_t = typename LocationSpecFor<std::remove_cvref_t<Arg>>::type
template<typename... Args>
using LocationSpecs_t = std::tuple<LocationSpec_t<Args>...>
template<typename... Args>
using TailLocationSpecs_t = typename TailLocationSpecs<Args...>::type
template<typename Tuple>
using first_or_empty_t = typename first_or_empty<Tuple>::type
template<typename Outputs, typename Traits_, typename... Args>
using DataHandleVectorMixin = DataHandleMixin<Outputs, type_list<handle_vector_input_t<Args>...>, Traits_>

Functions

std::vector< DataObjID > to_DataObjID (const std::vector< std::string > &in)
template<typename Value, std::size_t... I>
auto get_values_helper (std::index_sequence< I... >)
template<std::derived_from< DataObject > Out1, std::convertible_to< Out1 > Out2>
auto put (const DataObjectHandle< Out1 > &out_handle, Out2 &&out)
template<typename Out1, std::convertible_to< Out1 > Out2>
auto put (const DataObjectHandle< AnyDataWrapper< Out1 > > &out_handle, Out2 &&out)
template<template< typename > class Handle, typename Out, typename Value>
auto put (const HandleVector< Handle, Out > &out_handle, Value &&out)
template<typename OutHandle, typename OptOut>
void put (const OutHandle &out_handle, OptOut &&out)
template<typename Vectors>
decltype(auto) getLocations (Vectors const &vectors, unsigned int i)
template<typename F>
StatusCode execute (CommonMessagingBase const &alg, F &&f)
template<typename Tuple, typename Spec, std::size_t... I>
Tuple location_specs_tuple (std::initializer_list< Spec > specs, std::index_sequence< I... >, const char *component)
template<typename Handle, typename Algo>
auto get (const Handle &handle, const Algo &, const EventContext &) -> decltype(details::deref(handle.get()))
template<typename Algo>
const EventContext & get (const EventContextHandle &, const Algo &, const EventContext &ctx)
template<template< typename > class Handle, typename In, typename Algo>
auto get (const HandleVector< Handle, In > &handle, const Algo &, const EventContext &ctx)
template<typename IFace, typename Algo>
auto get (const ToolHandle< Gaudi::Interface::Bind::IBinder< IFace > > &handle, const Algo &, const EventContext &ctx)
template<typename Handle>
auto getKey (const Handle &h) -> decltype(h.objKey())
template<template< typename > class Handle, typename T>
auto getKey (const HandleVector< Handle, T > &h) -> decltype(h.locations())
template<typename OutHandles, typename Outputs>
void put_results (const OutHandles &out_handles, Outputs &&outputs)
template<typename Algorithm, typename OutHandles = std::tuple<>>
requires ( std::tuple_size_v<OutHandles> <= 1 )
StatusCode execute_single_output (const Algorithm &algo, const EventContext &ctx, const OutHandles &out_handles={})
template<typename Algorithm, typename OutHandles>
StatusCode execute_outputs (const Algorithm &algo, const EventContext &ctx, const OutHandles &out_handles)
template<typename Algorithm, typename OutHandles>
StatusCode execute_filtered_outputs (const Algorithm &algo, const EventContext &ctx, const OutHandles &out_handles)
template<typename... In, typename Traits_, bool isLegacy>
StatusCode execute_filter_predicate (const FilterPredicate< bool(const In &...), Traits_, isLegacy > &algo, const EventContext &ctx)
template<typename Fun, typename Container>
void applyPostProcessing (const Fun &fun, Container &c)

Variables

constexpr struct Gaudi::Functional::details::invoke_optionally_t invoke_optionally
constexpr struct Gaudi::Functional::details::insert_t insert
constexpr struct Gaudi::Functional::details::deref_t deref
template<typename Arg>
constexpr bool is_handle_vector_input_v = handle_vector_input<Arg>::is_range
template<typename T>
constexpr bool is_event_context_v = std::is_same_v<std::remove_cvref_t<T>, EventContext>
template<typename Tuple, typename T>
constexpr bool tuple_elements_are_v = false
template<typename T, typename... Elements>
constexpr bool tuple_elements_are_v< std::tuple< Elements... >, T > = ( std::same_as<Elements, T> && ... )
template<typename Tuple, typename T>
constexpr bool tuple_elements_constructible_from_v = false
template<typename T, typename... Elements>
constexpr bool tuple_elements_constructible_from_v< std::tuple< Elements... >, T >
template<typename... Args>
constexpr bool first_is_event_context_v = false
template<typename First, typename... Rest>
constexpr bool first_is_event_context_v< First, Rest... > = is_event_context_v<First>
template<bool starts_with_event_context, typename InputSpecTuple>
constexpr auto empty_input_specs
template<typename Traits>
constexpr bool isLegacy
template<typename Sig>
constexpr bool is_void_fun_v = false
template<typename... Args>
constexpr bool is_void_fun_v< void(Args...)> = true

Typedef Documentation

◆ BaseClass_t

template<typename Tr, typename Default = Gaudi::Algorithm>
using Gaudi::Functional::details::BaseClass_t = detail2::BaseClass<Tr, Default>::type

Definition at line 551 of file details.h.

◆ DataHandleVectorMixin

template<typename Outputs, typename Traits_, typename... Args>
using Gaudi::Functional::details::DataHandleVectorMixin = DataHandleMixin<Outputs, type_list<handle_vector_input_t<Args>...>, Traits_>

Definition at line 748 of file details.h.

◆ first_or_empty_t

template<typename Tuple>
using Gaudi::Functional::details::first_or_empty_t = typename first_or_empty<Tuple>::type

Definition at line 633 of file details.h.

◆ handle_vector_input_t

template<typename Arg>
using Gaudi::Functional::details::handle_vector_input_t = typename handle_vector_input<Arg>::type

Definition at line 436 of file details.h.

◆ InputHandle_t

template<typename Tr, typename T>
using Gaudi::Functional::details::InputHandle_t = typename detail2::InputHandle<T, Tr, detail2::DefaultInputHandle_t>::type

Definition at line 560 of file details.h.

◆ LocationSpec_t

template<typename Arg>
using Gaudi::Functional::details::LocationSpec_t = typename LocationSpecFor<std::remove_cvref_t<Arg>>::type

Definition at line 608 of file details.h.

◆ LocationSpecs_t

template<typename... Args>
using Gaudi::Functional::details::LocationSpecs_t = std::tuple<LocationSpec_t<Args>...>

Definition at line 611 of file details.h.

◆ OutputHandle_t

template<typename Tr, typename T>
using Gaudi::Functional::details::OutputHandle_t = typename detail2::OutputHandle<T, Tr, DataObjectWriteHandle>::type

Definition at line 557 of file details.h.

◆ remove_optional_t

template<typename T>
using Gaudi::Functional::details::remove_optional_t = typename details2::value_type_of<T>::type

Definition at line 70 of file details.h.

◆ RepeatValues_

template<typename Value, auto N>
using Gaudi::Functional::details::RepeatValues_ = decltype( get_values_helper<Value>( std::make_index_sequence<N>() ) )

Definition at line 98 of file details.h.

◆ TailLocationSpecs_t

template<typename... Args>
using Gaudi::Functional::details::TailLocationSpecs_t = typename TailLocationSpecs<Args...>::type

Definition at line 622 of file details.h.

Function Documentation

◆ applyPostProcessing()

template<typename Fun, typename Container>
void Gaudi::Functional::details::applyPostProcessing ( const Fun & fun,
Container & c )

Definition at line 18 of file ScalarTransformer.h.

18 {
19 if constexpr ( requires { fun.postprocess( c ); } ) { fun.postprocess( c ); }
20 }

◆ execute()

template<typename F>
StatusCode Gaudi::Functional::details::execute ( CommonMessagingBase const & alg,
F && f )

Definition at line 459 of file details.h.

459 {
460 try {
461 return std::forward<F>( f )();
462 } catch ( GaudiException& e ) {
463 if ( e.code().isFailure() ) alg.error() << e.tag() << " : " << e.message() << endmsg;
464 return e.code();
465 }
466 }
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition MsgStream.h:198
GaudiException
Define general base for Gaudi exception.
Definition GaudiException.h:29
GaudiException::message
virtual const std::string & message() const
error message to be printed
Definition GaudiException.h:66
GaudiException::code
virtual const StatusCode & code() const
StatusCode for Exception.
Definition GaudiException.h:84
GaudiException::tag
virtual const std::string & tag() const
name tag for the exception, or exception type
Definition GaudiException.h:75
StatusCode::isFailure
bool isFailure() const
Definition StatusCode.h:118

◆ execute_filter_predicate()

template<typename... In, typename Traits_, bool isLegacy>
StatusCode Gaudi::Functional::details::execute_filter_predicate ( const FilterPredicate< bool(const In &...), Traits_, isLegacy > & algo,
const EventContext & ctx )

Definition at line 23 of file FilterPredicate.h.

24 {
25 return details::execute(
26 algo, [&] { return algo.invoke( algo, ctx ) ? FilterDecision::PASSED : FilterDecision::FAILED; } );
27 }
Gaudi::Functional::details::execute
StatusCode execute(CommonMessagingBase const &alg, F &&f)
Definition details.h:459

◆ execute_filtered_outputs()

template<typename Algorithm, typename OutHandles>
StatusCode Gaudi::Functional::details::execute_filtered_outputs ( const Algorithm & algo,
const EventContext & ctx,
const OutHandles & out_handles )

Definition at line 970 of file details.h.

970 {
971 return execute( algo, [&] {
972 return std::apply(
973 [&]( bool passed, auto&&... data ) {
974 put_results( out_handles, std::forward_as_tuple( std::forward<decltype( data )>( data )... ) );
975 return passed;
976 },
977 algo.invoke( algo, ctx ) )
978 ? FilterDecision::PASSED
979 : FilterDecision::FAILED;
980 } );
981 }
Gaudi::Functional::details::put_results
void put_results(const OutHandles &out_handles, Outputs &&outputs)
Definition details.h:941

◆ execute_outputs()

template<typename Algorithm, typename OutHandles>
StatusCode Gaudi::Functional::details::execute_outputs ( const Algorithm & algo,
const EventContext & ctx,
const OutHandles & out_handles )

Definition at line 962 of file details.h.

962 {
963 return execute( algo, [&] {
964 put_results( out_handles, algo.invoke( algo, ctx ) );
965 return FilterDecision::PASSED;
966 } );
967 }

◆ execute_single_output()

template<typename Algorithm, typename OutHandles = std::tuple<>>
requires ( std::tuple_size_v<OutHandles> <= 1 )
StatusCode Gaudi::Functional::details::execute_single_output ( const Algorithm & algo,
const EventContext & ctx,
const OutHandles & out_handles = {} )

Definition at line 948 of file details.h.

948 {} )
949 requires( std::tuple_size_v<OutHandles> <= 1 )
950 {
951 return execute( algo, [&] {
952 if constexpr ( std::tuple_size_v<OutHandles> == 0 ) {
953 algo.invoke( algo, ctx );
954 } else {
955 put( std::get<0>( out_handles ), algo.invoke( algo, ctx ) );
956 }
957 return FilterDecision::PASSED;
958 } );
959 }
Gaudi::Functional::details::put
auto put(const DataObjectHandle< Out1 > &out_handle, Out2 &&out)
Definition details.h:103

◆ get() [1/4]

template<typename Algo>
const EventContext & Gaudi::Functional::details::get ( const EventContextHandle & ,
const Algo & ,
const EventContext & ctx )

Definition at line 720 of file details.h.

720 {
721 return ctx;
722 }

◆ get() [2/4]

template<typename Handle, typename Algo>
auto Gaudi::Functional::details::get ( const Handle & handle,
const Algo & ,
const EventContext &  ) -> decltype(details::deref(handle.get()))

Definition at line 713 of file details.h.

715 {
716 return details::deref( handle.get() );
717 }
Gaudi::Functional::details::deref
constexpr struct Gaudi::Functional::details::deref_t deref

◆ get() [3/4]

template<template< typename > class Handle, typename In, typename Algo>
auto Gaudi::Functional::details::get ( const HandleVector< Handle, In > & handle,
const Algo & ,
const EventContext & ctx )

Definition at line 725 of file details.h.

725 {
726 return handle.get( ctx );
727 }
Gaudi::Functional::details::HandleVector::get
vector_of_const_< I > get(EventContext const &) const
Definition details.h:396

◆ get() [4/4]

template<typename IFace, typename Algo>
auto Gaudi::Functional::details::get ( const ToolHandle< Gaudi::Interface::Bind::IBinder< IFace > > & handle,
const Algo & ,
const EventContext & ctx )

Definition at line 730 of file details.h.

730 {
731 return handle.bind( ctx );
732 }
ToolHandle< Gaudi::Interface::Bind::IBinder< IFace > >::bind
auto bind(const EventContext &ctx) const
Definition ToolHandle.h:341

◆ get_values_helper()

template<typename Value, std::size_t... I>
auto Gaudi::Functional::details::get_values_helper ( std::index_sequence< I... > )

Definition at line 93 of file details.h.

93 {
94 return std::make_tuple( ( (void)I, Value{} )... );
95 }

◆ getKey() [1/2]

template<typename Handle>
auto Gaudi::Functional::details::getKey ( const Handle & h) -> decltype(h.objKey())

Definition at line 735 of file details.h.

735 {
736 return h.objKey();
737 }

◆ getKey() [2/2]

template<template< typename > class Handle, typename T>
auto Gaudi::Functional::details::getKey ( const HandleVector< Handle, T > & h) -> decltype(h.locations())

Definition at line 740 of file details.h.

740 {
741 return h.locations();
742 }

◆ getLocations()

template<typename Vectors>
decltype(auto) Gaudi::Functional::details::getLocations ( Vectors const & vectors,
unsigned int i )

Definition at line 452 of file details.h.

452 {
453 return std::apply(
454 [i]( auto const&... elems ) -> decltype( auto ) { return *std::array{ &elems.locations()... }.at( i ); },
455 vectors );
456 }

◆ location_specs_tuple()

template<typename Tuple, typename Spec, std::size_t... I>
Tuple Gaudi::Functional::details::location_specs_tuple ( std::initializer_list< Spec > specs,
std::index_sequence< I... > ,
const char * component )

Definition at line 656 of file details.h.

656 {
657 if constexpr ( sizeof...( I ) == 1 ) {
658 if ( specs.size() == 0 ) return Tuple{ Spec{} };
659 }
660 if ( specs.size() != sizeof...( I ) ) {
661 throw GaudiException( "Wrong number of location specifications", component, StatusCode::FAILURE );
662 }
663 return Tuple{ *std::next( specs.begin(), I )... };
664 }
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition StatusCode.h:100

◆ put() [1/4]

template<typename Out1, std::convertible_to< Out1 > Out2>
auto Gaudi::Functional::details::put ( const DataObjectHandle< AnyDataWrapper< Out1 > > & out_handle,
Out2 && out )

Definition at line 108 of file details.h.

108 {
109 return out_handle.put( std::forward<Out2>( out ) );
110 }
DataObjectHandle::put
T * put(std::unique_ptr< T > object) const
Register object in transient store.
Definition DataObjectHandle.h:175

◆ put() [2/4]

template<std::derived_from< DataObject > Out1, std::convertible_to< Out1 > Out2>
auto Gaudi::Functional::details::put ( const DataObjectHandle< Out1 > & out_handle,
Out2 && out )

Definition at line 103 of file details.h.

103 {
104 return out_handle.put( std::make_unique<Out1>( std::forward<Out2>( out ) ) );
105 }

◆ put() [3/4]

template<template< typename > class Handle, typename Out, typename Value>
auto Gaudi::Functional::details::put ( const HandleVector< Handle, Out > & out_handle,
Value && out )

Definition at line 113 of file details.h.

113 {
114 return out_handle.put( std::forward<Value>( out ) );
115 }

◆ put() [4/4]

template<typename OutHandle, typename OptOut>
void Gaudi::Functional::details::put ( const OutHandle & out_handle,
OptOut && out )

Definition at line 120 of file details.h.

120 {
121 if ( out ) put( out_handle, *std::forward<OptOut>( out ) );
122 }

◆ put_results()

template<typename OutHandles, typename Outputs>
void Gaudi::Functional::details::put_results ( const OutHandles & out_handles,
Outputs && outputs )

Definition at line 941 of file details.h.

941 {
942 [&]<std::size_t... I>( std::index_sequence<I...> ) {
943 ( put( std::get<I>( out_handles ), std::get<I>( std::forward<Outputs>( outputs ) ) ), ... );
944 }( std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Outputs>>>{} );
945 }

◆ to_DataObjID()

std::vector< DataObjID > Gaudi::Functional::details::to_DataObjID ( const std::vector< std::string > & in)
inline

Definition at line 39 of file details.h.

39 {
40 std::vector<DataObjID> out;
41 out.reserve( in.size() );
42 std::transform( in.begin(), in.end(), std::back_inserter( out ),
43 []( const std::string& i ) { return DataObjID{ i }; } );
44 return out;
45 }

Variable Documentation

◆ deref

struct Gaudi::Functional::details::deref_t Gaudi::Functional::details::deref

◆ empty_input_specs

template<bool starts_with_event_context, typename InputSpecTuple>
auto Gaudi::Functional::details::empty_input_specs
inlineconstexpr
Initial value:
=
std::conditional_t<starts_with_event_context, InputSpecTuple, std::tuple<>>{}

Definition at line 652 of file details.h.

652 {};

◆ first_is_event_context_v

template<typename... Args>
bool Gaudi::Functional::details::first_is_event_context_v = false
inlineconstexpr

Definition at line 647 of file details.h.

◆ first_is_event_context_v< First, Rest... >

template<typename First, typename... Rest>
bool Gaudi::Functional::details::first_is_event_context_v< First, Rest... > = is_event_context_v<First>
inlineconstexpr

Definition at line 649 of file details.h.

◆ insert

struct Gaudi::Functional::details::insert_t Gaudi::Functional::details::insert

◆ invoke_optionally

struct Gaudi::Functional::details::invoke_optionally_t Gaudi::Functional::details::invoke_optionally

◆ is_event_context_v

template<typename T>
bool Gaudi::Functional::details::is_event_context_v = std::is_same_v<std::remove_cvref_t<T>, EventContext>
inlineconstexpr

Definition at line 563 of file details.h.

◆ is_handle_vector_input_v

template<typename Arg>
bool Gaudi::Functional::details::is_handle_vector_input_v = handle_vector_input<Arg>::is_range
inlineconstexpr

Definition at line 438 of file details.h.

◆ is_void_fun_v

template<typename Sig>
bool Gaudi::Functional::details::is_void_fun_v = false
constexpr

Definition at line 22 of file MergingTransformer.h.

◆ is_void_fun_v< void(Args...)>

template<typename... Args>
bool Gaudi::Functional::details::is_void_fun_v< void(Args...)> = true
constexpr

Definition at line 24 of file MergingTransformer.h.

◆ isLegacy

template<typename Traits>
bool Gaudi::Functional::details::isLegacy
inlineconstexpr
Initial value:
=
std::is_base_of_v<Gaudi::details::LegacyAlgorithmAdapter, details::BaseClass_t<Traits>>

Definition at line 707 of file details.h.

◆ tuple_elements_are_v

template<typename Tuple, typename T>
bool Gaudi::Functional::details::tuple_elements_are_v = false
inlineconstexpr

Definition at line 636 of file details.h.

◆ tuple_elements_are_v< std::tuple< Elements... >, T >

template<typename T, typename... Elements>
bool Gaudi::Functional::details::tuple_elements_are_v< std::tuple< Elements... >, T > = ( std::same_as<Elements, T> && ... )
inlineconstexpr

Definition at line 638 of file details.h.

◆ tuple_elements_constructible_from_v

template<typename Tuple, typename T>
bool Gaudi::Functional::details::tuple_elements_constructible_from_v = false
inlineconstexpr

Definition at line 641 of file details.h.

◆ tuple_elements_constructible_from_v< std::tuple< Elements... >, T >

template<typename T, typename... Elements>
bool Gaudi::Functional::details::tuple_elements_constructible_from_v< std::tuple< Elements... >, T >
inlineconstexpr
Initial value:
=
( std::constructible_from<Elements, T> && ... )

Definition at line 643 of file details.h.