ranges::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	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	require_is_optional = std::enable_if_t< is_optional_v< Arg > >
template<typename Arg >
using	require_is_not_optional = std::enable_if_t<!is_optional_v< Arg > >
template<typename T >
using	remove_optional_t = std::conditional_t< is_optional_v< T >, typename T::value_type, T >
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 Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible_v<Out1, Out2> && std::is_base_of_v<DataObject, Out1>>>
Out1 *	put (const DataObjectHandle< Out1 > &out_handle, Out2 &&out)
template<typename Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible_v<Out1, Out2>>>
void	put (const DataObjectHandle< AnyDataWrapper< Out1 >> &out_handle, Out2 &&out)
template<typename OutHandle , typename OptOut , typename = require_is_optional<OptOut>>
void	put (const OutHandle &out_handle, OptOut &&out)
template<typename Handles >
Handles	make_vector_of_handles (IDataHandleHolder *owner, const std::vector< std::string > &init)
template<typename Handle , typename Algo >
auto	get (const Handle &handle, const Algo &, const EventContext &) -> decltype(details::deref(handle.get()))
template<typename Handle >
auto	getKey (const Handle &h) -> decltype(h.objKey())
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)
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
template<typename Arg >
constexpr bool	is_optional_v = Gaudi::cpp17::is_detected_v<details2::is_optional_, Arg>
constexpr struct ranges::Gaudi::Functional::details::invoke_optionally_t	invoke_optionally
constexpr struct ranges::Gaudi::Functional::details::insert_t	insert
constexpr struct ranges::Gaudi::Functional::details::deref_t	deref
template<typename Traits >
constexpr bool	isLegacy

Typedef Documentation

BaseClass_t

template<typename Tr >

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

Definition at line 319 of file FunctionalDetails.h.

filter_evtcontext

template<typename... In>

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

Definition at line 403 of file FunctionalDetails.h.

InputHandle_t

template<typename Tr , typename T >

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

Definition at line 327 of file FunctionalDetails.h.

OutputHandle_t

template<typename Tr , typename T >

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

Definition at line 325 of file FunctionalDetails.h.

remove_optional_t

template<typename T >

using ranges::Gaudi::Functional::details::remove_optional_t = typedef std::conditional_t<is_optional_v<T>, typename T::value_type, T>

Definition at line 121 of file FunctionalDetails.h.

require_is_not_optional

template<typename Arg >

using ranges::Gaudi::Functional::details::require_is_not_optional = typedef std::enable_if_t<!is_optional_v<Arg> >

Definition at line 118 of file FunctionalDetails.h.

require_is_optional

template<typename Arg >

using ranges::Gaudi::Functional::details::require_is_optional = typedef std::enable_if_t<is_optional_v<Arg> >

Definition at line 115 of file FunctionalDetails.h.

Function Documentation

applyPostProcessing() [1/2]

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

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

Definition at line 576 of file FunctionalDetails.h.

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

applyPostProcessing() [2/2]

template<typename Fun , typename Container >

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

Definition at line 581 of file FunctionalDetails.h.

                                                                                                       {
    fun.postprocess( c );
  }

get()

template<typename Handle , typename Algo >

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

Definition at line 348 of file FunctionalDetails.h.

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

getKey()

template<typename Handle >

auto ranges::Gaudi::Functional::details::getKey

(

const Handle &

h

)

-> decltype( h.objKey() )

Definition at line 355 of file FunctionalDetails.h.

                                                           {
    return h.objKey();
  }

make_vector_of_handles()

template<typename Handles >

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

Definition at line 336 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;
  }

put() [1/3]

template<typename Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible_v<Out1, Out2> && std::is_base_of_v<DataObject, Out1>>>

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

Definition at line 137 of file FunctionalDetails.h.

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

put() [2/3]

template<typename Out1 , typename Out2 , typename = std::enable_if_t<std::is_constructible_v<Out1, Out2>>>

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

Definition at line 142 of file FunctionalDetails.h.

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

put() [3/3]

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

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

Definition at line 148 of file FunctionalDetails.h.

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

updateHandleLocation()

template<typename Out , typename In , typename Tr >

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

Definition at line 409 of file FunctionalDetails.h.

                                                       {
    auto sc = parent.setProperty( prop, newLoc );
    if ( sc.isFailure() ) throw GaudiException( "Could not set Property", prop + " -> " + newLoc, sc );
  }

updateHandleLocations()

template<typename Out , typename In , typename Tr >

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

Definition at line 416 of file FunctionalDetails.h.

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

Variable Documentation

deref

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

insert

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

invoke_optionally

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

is_optional_v

template<typename Arg >

constexpr bool ranges::Gaudi::Functional::details::is_optional_v = Gaudi::cpp17::is_detected_v<details2::is_optional_, Arg>

Definition at line 112 of file FunctionalDetails.h.

isLegacy

template<typename Traits >

constexpr bool ranges::Gaudi::Functional::details::isLegacy

inline

Initial value:

=
      std::is_base_of_v<Gaudi::details::LegacyAlgorithmAdapter, details::BaseClass_t<Traits>>

Definition at line 330 of file FunctionalDetails.h.