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< std::tuple< void >, std::tuple<>, Traits_ >
struct	deref_t
struct	filter_evtcontext_t
struct	filter_evtcontext_t< EventContext, In... >
struct	FilterPredicate
struct	FilterPredicate< bool(const In &...), Traits_, false >
struct	FilterPredicate< bool(const In &...), Traits_, true >
class	HandleVector
struct	insert_t
struct	invoke_optionally_t
struct	MergingTransformer
struct	MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, false >
struct	MergingTransformer< Out(const vector_of_const_< Ins > &...), Traits_, true >
struct	Producer
class	SplittingMergingTransformer
class	SplittingMergingTransformer< vector_of_< Out >(const vector_of_const_< In > &), Traits_ >
class	SplittingTransformer
class	SplittingTransformer< vector_of_< Out >(const In &...), Traits_ >
class	ToolBinder
class	ToolBinder< Gaudi::Interface::Bind::Box< IFace >(Args const &...), Traits >
class	vector_of_const_

Concepts
concept	is_optional
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 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>::type
template<typename... In>
using	filter_evtcontext = typename filter_evtcontext_t<In...>::type

Functions
template<typename Handles>
Handles	make_vector_of_handles (IDataHandleHolder *owner, const std::vector< DataObjID > &init)
template<typename Out, typename In, typename Tr>
void	updateHandleLocation (DataHandleMixin< Out, In, Tr > &parent, const std::string &prop, const std::string &newLoc)
template<typename Out, typename In, typename Tr>
void	updateHandleLocations (DataHandleMixin< Out, In, Tr > &parent, const std::string &prop, const std::vector< std::string > &newLocs)
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<typename OutHandle, typename OptOut> requires ( is_optional<OptOut> )
void	put (const OutHandle &out_handle, OptOut &&out)
template<template< typename > class Handle, typename... I, typename Algorithm, typename InKeys>
auto	make_HandleVectorTuple (Algorithm *parent, InKeys const &keys)
template<template< typename > class Handle, typename... I>
decltype(auto)	getLocations (std::tuple< HandleVector< Handle, I >... > const &vectors, unsigned int i)
template<typename F>
StatusCode	execute (CommonMessagingBase const &alg, F &&f)
template<typename Handle, typename Algo>
auto	get (const Handle &handle, const Algo &, const EventContext &) -> decltype(details::deref(handle.get()))
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<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 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 485 of file details.h.

filter_evtcontext

template<typename... In>

using Gaudi::Functional::details::filter_evtcontext = typename filter_evtcontext_t<In...>::type

Definition at line 549 of file details.h.

InputHandle_t

template<typename Tr, typename T>

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

Definition at line 494 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 491 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.

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.

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

execute()

template<typename F>

StatusCode Gaudi::Functional::details::execute	(	CommonMessagingBase const &	alg,
		F &&	f )

Definition at line 429 of file details.h.

                                                              {
    try {
      return std::forward<F>( f )();
    } catch ( GaudiException& e ) {
      if ( e.code().isFailure() ) alg.error() << e.tag() << " : " << e.message() << endmsg;
      return e.code();
    }
  }

get() [1/2]

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

  {
    return details::deref( handle.get() );
  }

get() [2/2]

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

                                                                                                               {
    return handle.bind( ctx );
  }

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.

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

getKey()

template<typename Handle>

auto Gaudi::Functional::details::getKey

(

const Handle &

h

)

-> decltype( h.objKey() )

Definition at line 515 of file details.h.

                                                           {
    return h.objKey();
  }

getLocations()

template<template< typename > class Handle, typename... I>

decltype(auto) Gaudi::Functional::details::getLocations	(	std::tuple< HandleVector< Handle, I >... > const &	vectors,
		unsigned int	i )

Definition at line 422 of file details.h.

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

make_HandleVectorTuple()

template<template< typename > class Handle, typename... I, typename Algorithm, typename InKeys>

auto Gaudi::Functional::details::make_HandleVectorTuple	(	Algorithm *	parent,
		InKeys const &	keys )

Definition at line 412 of file details.h.

                                                                       {
    return std::apply(
        [parent]( auto const&... key ) {
          static_assert( sizeof...( key ) == sizeof...( I ) );
          return std::tuple{ HandleVector<Handle, I>{ parent, key }... };
        },
        keys );
  }

make_vector_of_handles()

template<typename Handles>

Handles Gaudi::Functional::details::make_vector_of_handles	(	IDataHandleHolder *	owner,
		const std::vector< DataObjID > &	init )

Definition at line 23 of file deprecated.h.

                                                                                                              {
    Handles handles;
    handles.reserve( init.size() );
    std::transform( init.begin(), init.end(), std::back_inserter( handles ),
                    [&]( const auto& loc ) -> typename Handles::value_type {
                      return { loc, owner };
                    } );
    return handles;
  }

put() [1/3]

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.

                                                                                   {
    return out_handle.put( std::forward<Out2>( out ) );
  }

put() [2/3]

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.

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

put() [3/3]

template<typename OutHandle, typename OptOut>
requires ( is_optional<OptOut> )

void Gaudi::Functional::details::put	(	const OutHandle &	out_handle,
		OptOut &&	out )

Definition at line 115 of file details.h.

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

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.

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

updateHandleLocation()

template<typename Out, typename In, typename Tr>

void Gaudi::Functional::details::updateHandleLocation	(	DataHandleMixin< Out, In, Tr > &	parent,
		const std::string &	prop,
		const std::string &	newLoc )

Definition at line 37 of file deprecated.h.

                                                                      {
    parent.setProperty( prop, newLoc ).orThrow( "Could not set Property", prop + " -> " + newLoc );
  }

updateHandleLocations()

template<typename Out, typename In, typename Tr>

void Gaudi::Functional::details::updateHandleLocations	(	DataHandleMixin< Out, In, Tr > &	parent,
		const std::string &	prop,
		const std::vector< std::string > &	newLocs )

Definition at line 43 of file deprecated.h.

                                                                                   {
    std::ostringstream ss;
    GaudiUtils::details::ostream_joiner( ss << '[', newLocs, ", ", []( std::ostream& os, const auto& i ) -> auto& {
      return os << "'" << i << "'";
    } ) << ']';
    parent.setProperty( prop, ss.str() ).orThrow( "Could not set Property", prop + " -> " + ss.str() );
  }

Variable Documentation

deref

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

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_void_fun_v

template<typename Sig>

bool Gaudi::Functional::details::is_void_fun_v = false

constexpr

Definition at line 23 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 25 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 497 of file details.h.