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_ >

struct	deref_t

struct	insert_t

struct	is_optional

struct	is_optional< boost::optional< T > >

class	vector_of_const_

Typedefs
template<typename T >
using	remove_optional_t = typename details2::remove_optional< T >::type

template<typename Default , template< typename... > class Op, typename... Args>
using	detected_or_t = typename detail2::detector< Default, void, Op, Args... >::type

template<template< typename... > class Default, template< typename... > class Op, typename Tr , typename T >
using	detected_or_t_ = detected_or_t< Default< Tr, T >, Op, Tr, T >

template<typename Tr >
using	BaseClass_t = detected_or_t< GaudiAlgorithm, detail2::BaseClass_, Tr >

template<typename Tr , typename T >
using	OutputHandle_t = detected_or_t_< detail2::defaultHandle_, detail2::OutputHandle_, Tr, T >

template<typename Tr , typename T >
using	InputHandle_t = detected_or_t_< detail2::defaultHandle_, detail2::InputHandle_, Tr, T >

Functions
template<typename T >
constexpr std::add_const< T >::type &	as_const (T &t) noexcept

template<typename T >
void	as_const (T &&t)=delete

template<typename Out1 , typename Out2 , typename = typename std::enable_if<std::is_constructible<Out1, Out2>::value>::type>
Out1 *	put (DataObjectHandle< Out1 > &out_handle, Out2 &&out)

template<typename Out1 , typename Out2 , typename = typename std::enable_if<std::is_constructible<Out1, Out2>::value>::type>
void	put (AnyDataHandle< Out1 > &out_handle, Out2 &&out)

template<typename OutHandle , typename Out >
void	put (OutHandle &out_handle, boost::optional< Out > &&out)

template<typename Tuple , typename KeyValues >
Tuple	make_tuple_of_handles (IDataHandleHolder *owner, const KeyValues &initvalue, Gaudi::DataHandle::Mode mode)

template<typename KeyValues , typename Properties >
void	declare_tuple_of_properties (Algorithm &owner, const KeyValues &inputs, Properties &props)

template<typename Handles >
Handles	make_vector_of_handles (IDataHandleHolder *owner, const std::vector< std::string > &init, Gaudi::DataHandle::Mode mode)

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::insert_t	insert

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

Typedef Documentation

template<typename Tr >

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

Definition at line 374 of file FunctionalDetails.h.

template<typename Default , template< typename... > class Op, typename... Args>

using Gaudi::Functional::details::detected_or_t = typedef typename detail2::detector<Default, void, Op, Args...>::type

Definition at line 349 of file FunctionalDetails.h.

template<template< typename... > class Default, template< typename... > class Op, typename Tr , typename T >

using Gaudi::Functional::details::detected_or_t_ = typedef detected_or_t<Default<Tr, T>, Op, Tr, T>

Definition at line 353 of file FunctionalDetails.h.

template<typename Tr , typename T >

using Gaudi::Functional::details::InputHandle_t = typedef detected_or_t_<detail2::defaultHandle_, detail2::InputHandle_, Tr, T>

Definition at line 383 of file FunctionalDetails.h.

template<typename Tr , typename T >

using Gaudi::Functional::details::OutputHandle_t = typedef detected_or_t_<detail2::defaultHandle_, detail2::OutputHandle_, Tr, T>

Definition at line 381 of file FunctionalDetails.h.

template<typename T >

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

Definition at line 203 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 579 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 585 of file FunctionalDetails.h.

       {
         fun.postprocess( c );
       }

template<typename T >

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

noexcept

Definition at line 104 of file FunctionalDetails.h.

       {
         return t;
       }

template<typename T >

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

delete

template<typename KeyValues , typename Properties >

void Gaudi::Functional::details::declare_tuple_of_properties	(	Algorithm &	owner,
		const KeyValues &	inputs,
		Properties &	props
	)

Definition at line 415 of file FunctionalDetails.h.

       {
         constexpr auto N = std::tuple_size<KeyValues>::value;
         static_assert( N == std::tuple_size<Properties>::value, "Inconsistent lengths" );
         details2::declare_tuple_of_properties_helper( owner, inputs, props, std::make_index_sequence<N>{} );
       }

template<typename Tuple , typename KeyValues >

Tuple Gaudi::Functional::details::make_tuple_of_handles	(	IDataHandleHolder *	owner,
		const KeyValues &	initvalue,
		Gaudi::DataHandle::Mode	mode
	)

Definition at line 408 of file FunctionalDetails.h.

       {
         return details2::make_tuple_of_handles_helper<Tuple>(
             owner, initvalue, mode, std::make_index_sequence<std::tuple_size<Tuple>::value>{} );
       }

template<typename Handles >

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

Definition at line 423 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, mode, owner};
                         } );
         return handles;
       }

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

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

Definition at line 116 of file FunctionalDetails.h.

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

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

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

Definition at line 123 of file FunctionalDetails.h.

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

template<typename OutHandle , typename Out >

void Gaudi::Functional::details::put	(	OutHandle &	out_handle,
		boost::optional< Out > &&	out
	)

Definition at line 130 of file FunctionalDetails.h.

       {
         if ( out ) put( out_handle, std::move( *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

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation