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

Namespaces

namespace  detail2
namespace  details2
namespace  zip

Classes

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

Concepts

concept  has_handle_vector_input
concept  is_optional
concept  is_void_fun
concept  location_vector_handle

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>
void put (const Gaudi::DataHandleVector< Handle, Out > &out_handle, Value &&out)
template<typename OutHandle, typename OptOut>
requires ( is_optional<OptOut> )
void put (const OutHandle &out_handle, OptOut &&out)
template<typename Vectors>
decltype(auto) getKeys (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 Gaudi::DataHandleVector< Handle, In > &handle, const Algo &, const EventContext &)
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 Gaudi::DataHandleVector< Handle, T > &h) -> decltype(h.keys())
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 490 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 690 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 572 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 376 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 499 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 547 of file details.h.

◆ LocationSpecs_t

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

Definition at line 550 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 496 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 67 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 95 of file details.h.

◆ TailLocationSpecs_t

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

Definition at line 561 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 398 of file details.h.

398 {
399 try {
400 return std::forward<F>( f )();
401 } catch ( GaudiException& e ) {
402 if ( e.code().isFailure() ) alg.error() << e.tag() << " : " << e.message() << endmsg;
403 return e.code();
404 }
405 }
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:398

◆ 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 910 of file details.h.

910 {
911 return execute( algo, [&] {
912 return std::apply(
913 [&]( bool passed, auto&&... data ) {
914 put_results( out_handles, std::forward_as_tuple( std::forward<decltype( data )>( data )... ) );
915 return passed;
916 },
917 algo.invoke( algo, ctx ) )
918 ? FilterDecision::PASSED
919 : FilterDecision::FAILED;
920 } );
921 }
Gaudi::Functional::details::put_results
void put_results(const OutHandles &out_handles, Outputs &&outputs)
Definition details.h:881

◆ 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 902 of file details.h.

902 {
903 return execute( algo, [&] {
904 put_results( out_handles, algo.invoke( algo, ctx ) );
905 return FilterDecision::PASSED;
906 } );
907 }

◆ 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 888 of file details.h.

888 {} )
889 requires( std::tuple_size_v<OutHandles> <= 1 )
890 {
891 return execute( algo, [&] {
892 if constexpr ( std::tuple_size_v<OutHandles> == 0 ) {
893 algo.invoke( algo, ctx );
894 } else {
895 put( std::get<0>( out_handles ), algo.invoke( algo, ctx ) );
896 }
897 return FilterDecision::PASSED;
898 } );
899 }
Gaudi::Functional::details::put
auto put(const DataObjectHandle< Out1 > &out_handle, Out2 &&out)
Definition details.h:100

◆ get() [1/4]

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

Definition at line 659 of file details.h.

659 {
660 return ctx;
661 }

◆ get() [2/4]

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

Definition at line 664 of file details.h.

664 {
665 vector_of_const_<In> ins;
666 ins.reserve( handle.handles().size() );
667 std::ranges::transform( handle.handles(), std::back_inserter( ins ), details2::get_from_handle<In>{} );
668 return ins;
669 }
Gaudi::DataHandleVector::handles
const std::vector< Handle< T > > & handles() const
Typed handles, in property order.
Definition DataHandle.h:193
Gaudi::Functional::details::vector_of_const_
Definition details.h:304
Gaudi::Functional::details::vector_of_const_::reserve
void reserve(size_type size)
Definition details.h:335
Gaudi::Functional::details::details2::get_from_handle
Definition details.h:196

◆ get() [3/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 652 of file details.h.

654 {
655 return details::deref( handle.get() );
656 }
Gaudi::Functional::details::deref
constexpr struct Gaudi::Functional::details::deref_t deref

◆ 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 672 of file details.h.

672 {
673 return handle.bind( ctx );
674 }
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 90 of file details.h.

90 {
91 return std::make_tuple( ( (void)I, Value{} )... );
92 }

◆ getKey() [1/2]

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

Definition at line 682 of file details.h.

682 {
683 return h.keys();
684 }

◆ getKey() [2/2]

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

Definition at line 677 of file details.h.

677 {
678 return h.objKey();
679 }

◆ getKeys()

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

Definition at line 392 of file details.h.

392 {
393 return std::apply(
394 [i]( auto const&... elems ) -> decltype( auto ) { return *std::array{ &elems.keys()... }.at( i ); }, vectors );
395 }

◆ 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 595 of file details.h.

595 {
596 if constexpr ( sizeof...( I ) == 1 ) {
597 if ( specs.size() == 0 ) return Tuple{ Spec{} };
598 }
599 if ( specs.size() != sizeof...( I ) ) {
600 throw GaudiException( "Wrong number of location specifications", component, StatusCode::FAILURE );
601 }
602 return Tuple{ *std::next( specs.begin(), I )... };
603 }
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 105 of file details.h.

105 {
106 return out_handle.put( std::forward<Out2>( out ) );
107 }
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 100 of file details.h.

100 {
101 return out_handle.put( std::make_unique<Out1>( std::forward<Out2>( out ) ) );
102 }

◆ put() [3/4]

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

Definition at line 110 of file details.h.

110 {
111 auto const n = out_handle.size();
112 if ( out.size() != n ) {
113 throw GaudiException( "Error during transform in " +
114 std::string{ std::source_location::current().function_name() } + ": expected " +
115 std::to_string( n ) + " containers, got " + std::to_string( out.size() ) + " instead",
116 "Gaudi::Functional::details::put", StatusCode::FAILURE );
117 }
118 for ( std::size_t i = 0; i != n; ++i ) details::put( out_handle.handles()[i], std::move( out[i] ) );
119 }
Gaudi::DataHandleVector::size
auto size() const
Number of configured handles.
Definition DataHandle.h:197

◆ put() [4/4]

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

Definition at line 124 of file details.h.

124 {
125 if ( out ) put( out_handle, *std::forward<OptOut>( out ) );
126 }

◆ put_results()

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

Definition at line 881 of file details.h.

881 {
882 [&]<std::size_t... I>( std::index_sequence<I...> ) {
883 ( put( std::get<I>( out_handles ), std::get<I>( std::forward<Outputs>( outputs ) ) ), ... );
884 }( std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Outputs>>>{} );
885 }

◆ to_DataObjID()

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

Definition at line 36 of file details.h.

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

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 591 of file details.h.

591 {};

◆ first_is_event_context_v

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

Definition at line 586 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 588 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 502 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 378 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 646 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 575 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 577 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 580 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 582 of file details.h.