Gaudi::Functional::details Namespace Reference

Namespaces
	detail2
	details2
	zip

Classes
class	DataHandleMixin
class	DataHandleMixin< std::tuple< Out... >, std::tuple< In... >, Traits_ >
class	DataHandleMixin< std::tuple< Out... >, void, Traits_ >
class	DataHandleMixin< void, std::tuple< In... >, Traits_ >
class	DataHandleMixin< void, std::tuple<>, Traits_ >
struct	deref_t
struct	disjunction
struct	disjunction< B1 >
struct	disjunction< B1, Bn... >
struct	filter_evtcontext_t
struct	filter_evtcontext_t< EventContext, In... >
struct	insert_t
struct	invoke_optionally_t
class	vector_of_const_

Typedefs
template<typename Arg >
using	is_optional = typename Gaudi::cpp17::is_detected< details2::is_optional_, Arg >
template<typename Arg >
using	require_is_optional = std::enable_if_t< is_optional< Arg >::value >
template<typename Arg >
using	require_is_not_optional = std::enable_if_t<!is_optional< Arg >::value >
template<typename T >
using	remove_optional_t = typename details2::remove_optional< T >::type
template<typename Tr >
using	BaseClass_t = Gaudi::cpp17::detected_or_t< GaudiAlgorithm, detail2::BaseClass_t, Tr >
template<typename Tr , typename T >
using	OutputHandle_t = Gaudi::cpp17::detected_or_t< DataObjectWriteHandle< T >, detail2::OutputHandle_t, Tr, T >
template<typename Tr , typename T >
using	InputHandle_t = Gaudi::cpp17::detected_or_t< DataObjectReadHandle< T >, detail2::InputHandle_t, Tr, T >
template<typename... In>
using	filter_evtcontext = typename filter_evtcontext_t< In... >::type

Functions
template<typename T >
constexpr std::add_const_t< T > &	as_const (T &t) noexcept
template<typename T >
void	as_const (T &&t)=delete
template<typename Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible<Out1, Out2>::value && std::is_base_of<DataObject, Out1>::value>>
Out1 *	put (DataObjectHandle< Out1 > &out_handle, Out2 &&out)
template<typename Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible<Out1, Out2>::value>>
void	put (DataObjectHandle< AnyDataWrapper< Out1 >> &out_handle, Out2 &&out)
template<typename OutHandle , typename OptOut , typename = require_is_optional<OptOut>>
void	put (OutHandle &out_handle, OptOut &&out)
template<typename Handles >
Handles	make_vector_of_handles (IDataHandleHolder *owner, const std::vector< std::string > &init)
template<typename Fun , typename Container , typename... Args>
constexpr void	applyPostProcessing (const Fun &, Container &, Args...)
template<typename Fun , typename Container >
auto	applyPostProcessing (const Fun &fun, Container &c) -> decltype(fun.postprocess(c), void())

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

Typedef Documentation

template<typename Tr >

using Gaudi::Functional::details::BaseClass_t = typedef Gaudi::cpp17::detected_or_t<GaudiAlgorithm, detail2::BaseClass_t, Tr>

Definition at line 335 of file FunctionalDetails.h.

template<typename... In>

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

Definition at line 393 of file FunctionalDetails.h.

template<typename Tr , typename T >

using Gaudi::Functional::details::InputHandle_t = typedef Gaudi::cpp17::detected_or_t<DataObjectReadHandle<T>, detail2::InputHandle_t, Tr, T>

Definition at line 343 of file FunctionalDetails.h.

template<typename Arg >

using Gaudi::Functional::details::is_optional = typedef typename Gaudi::cpp17::is_detected<details2::is_optional_, Arg>

Definition at line 124 of file FunctionalDetails.h.

template<typename Tr , typename T >

using Gaudi::Functional::details::OutputHandle_t = typedef Gaudi::cpp17::detected_or_t<DataObjectWriteHandle<T>, detail2::OutputHandle_t, Tr, T>

Definition at line 341 of file FunctionalDetails.h.

template<typename T >

using Gaudi::Functional::details::remove_optional_t = typedef typename details2::remove_optional<T>::type

Definition at line 145 of file FunctionalDetails.h.

template<typename Arg >

using Gaudi::Functional::details::require_is_not_optional = typedef std::enable_if_t<!is_optional<Arg>::value>

Definition at line 130 of file FunctionalDetails.h.

template<typename Arg >

using Gaudi::Functional::details::require_is_optional = typedef std::enable_if_t<is_optional<Arg>::value>

Definition at line 127 of file FunctionalDetails.h.

Function Documentation

template<typename Fun , typename Container , typename... Args>

constexpr void Gaudi::Functional::details::applyPostProcessing	(	const Fun &	,
		Container &	,
		Args...
	)

Definition at line 553 of file FunctionalDetails.h.

                                                                            {
        static_assert( sizeof...( Args ) == 0, "Args should not be used!" );
      }

template<typename Fun , typename Container >

auto Gaudi::Functional::details::applyPostProcessing	(	const Fun &	fun,
		Container &	c
	)		-> decltype( fun.postprocess( c ), void() )

Definition at line 558 of file FunctionalDetails.h.

                                                                                                           {
        fun.postprocess( c );
      }

template<typename T >

constexpr std::add_const_t<T>& Gaudi::Functional::details::as_const ( T &  t )

noexcept

Definition at line 98 of file FunctionalDetails.h.

                                                             {
        return t;
      }

template<typename T >

void Gaudi::Functional::details::as_const ( T &&  t )

delete

template<typename Handles >

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

Definition at line 348 of file FunctionalDetails.h.

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

template<typename Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible<Out1, Out2>::value && std::is_base_of<DataObject, Out1>::value>>

Out1* Gaudi::Functional::details::put	(	DataObjectHandle< Out1 > &	out_handle,
		Out2 &&	out
	)

Definition at line 162 of file FunctionalDetails.h.

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

template<typename Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible<Out1, Out2>::value>>

void Gaudi::Functional::details::put	(	DataObjectHandle< AnyDataWrapper< Out1 >> &	out_handle,
		Out2 &&	out
	)

Definition at line 167 of file FunctionalDetails.h.

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

template<typename OutHandle , typename OptOut , typename = require_is_optional<OptOut>>

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

Definition at line 173 of file FunctionalDetails.h.

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

Variable Documentation

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

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

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