Namespaces
	details

	Traits

Classes
class	Consumer

class	Consumer< void(const In &...), Traits_ >

class	FilterPredicate

class	FilterPredicate< bool(const In &...), Traits_ >

class	MergingTransformer

class	MultiScalarTransformer

class	MultiScalarTransformer< ScalarOp, std::tuple< Out... >(const In &...), Traits_ >

class	MultiTransformer

class	MultiTransformer< std::tuple< Out... >(const In &...), Traits_ >

class	MultiTransformerFilter

class	MultiTransformerFilter< std::tuple< Out... >(const In &...), Traits_ >

class	Producer

class	ScalarTransformer

class	ScalarTransformer< ScalarOp, Out(const In &...), Traits_ >

class	SplittingTransformer

class	SplittingTransformer< vector_of_< Out >(const In &...), Traits_ >

class	Transformer

class	Transformer< Out(const In &...), Traits_ >

Typedefs
template<typename Container >
using	vector_of_ = details::template vector_of_const_< Container >

using	KeyValue = std::pair< std::string, std::string >

using	KeyValues = std::pair< std::string, std::vector< std::string >>

template<typename T >
using	InputHandle_t = details::InputHandle_t< Traits_, typename std::remove_pointer< T >::type >

template<typename Container >
using	vector_of_optional_ = std::vector< boost::optional< Container >>

Functions
std::string	concat_alternatives (std::initializer_list< std::string > c)

template<typename... Strings>
std::string	concat_alternatives (const Strings &...s)

void	updateHandleLocation (IProperty &parent, const std::string &prop, const std::string &newLoc)

void	updateHandleLocations (IProperty &parent, const std::string &prop, const std::vector< std::string > &newLocs)

void	updateReadHandleLocation (IProperty &parent, const std::string &prop, const std::string &newLoc)

template<typename Signature , typename Traits_ = Traits::useDefaults>
struct	deprecated ("use MergingTransformer instead")]] ListTransformer

	MergingTransformer (const std::string &name, ISvcLocator *locator, const KeyValues &inputs, const KeyValue &output)

StatusCode	execute () override final

virtual Out	operator() (const vector_of_const_< In > &inputs) const =0

Variables
template<typename Out , typename In , typename Traits_ >
class MergingTransformer< Out(const vector_of_const_< In >	Traits_

template<typename Out , typename In , typename Traits_ >
class MergingTransformer< Out(const vector_of_const_< In >	void

std::vector< std::string >	m_inputLocations

std::vector< InputHandle_t< In > >	m_inputs

Typedef Documentation

template<typename T >

using Gaudi::Functional::InputHandle_t = typedef details::InputHandle_t<Traits_,typename std::remove_pointer<T>::type>

private

Definition at line 37 of file MergingTransformer.h.

using Gaudi::Functional::KeyValue = typedef std::pair<std::string, std::string>

Definition at line 24 of file MergingTransformer.h.

using Gaudi::Functional::KeyValues = typedef std::pair<std::string, std::vector<std::string>>

Definition at line 25 of file MergingTransformer.h.

template<typename Container >

using Gaudi::Functional::vector_of_ = typedef std::vector<Container>

Definition at line 7 of file ListTransformer.h.

template<typename Container >

using Gaudi::Functional::vector_of_optional_ = typedef std::vector<boost::optional<Container>>

Definition at line 16 of file SplittingTransformer.h.

Function Documentation

std::string Gaudi::Functional::concat_alternatives ( std::initializer_list< std::string > c )

inline

Definition at line 18 of file FunctionalUtilities.h.

                                                                           {
       return boost::algorithm::join(c,":");
    }

template<typename... Strings>

std::string Gaudi::Functional::concat_alternatives ( const Strings &... s )

Definition at line 23 of file FunctionalUtilities.h.

                                                        {
       return concat_alternatives(std::initializer_list<std::string>{ s... });
    }

template<typename Signature , typename Traits_ = Traits::useDefaults>

struct Gaudi::Functional::deprecated ( "use MergingTransformer instead" )

Definition at line 9 of file ListTransformer.h.

                    : MergingTransformer<Signature,Traits_> {
         using MergingTransformer<Signature,Traits_>::MergingTransformer;
    };

StatusCode Gaudi::Functional::execute ( )

finaloverride

Gaudi::Functional::MergingTransformer< Out, In, Traits_ >::MergingTransformer	(	const std::string &	name,
		ISvcLocator *	locator,
		const KeyValues &	inputs,
		const KeyValue &	output
	)

Definition at line 44 of file MergingTransformer.h.

    :   base_class( name , pSvcLocator, output )
    ,   m_inputLocations( inputs.second )
    {
        // TODO/FIXME: replace vector of string property + call-back with a
        //             vector<handle> property ... as soon as declareProperty can deal with that.
        auto p = this->declareProperty( inputs.first, m_inputLocations );
        p->declareUpdateHandler( [=](Gaudi::Details::PropertyBase&) {
            this->m_inputs = details::make_vector_of_handles<decltype(this->m_inputs)>
                             (this, m_inputLocations, Gaudi::DataHandle::Reader);
            if (std::is_pointer<In>::value) { // handle constructor does not (yet) allow to set optional flag... so do it explicitly here...
                std::for_each( this->m_inputs.begin(), this->m_inputs.end(), [](auto& h) { h.setOptional(true); } );
            }
        } );
        p->useUpdateHandler(); // invoke call-back now, to be sure the input handles are synced with the property...
    }

virtual Out Gaudi::Functional::operator() ( const vector_of_const_< In > & inputs ) const

pure virtual

void Gaudi::Functional::updateHandleLocation	(	IProperty &	parent,
		const std::string &	prop,
		const std::string &	newLoc
	)

inline

Definition at line 27 of file FunctionalUtilities.h.

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

void Gaudi::Functional::updateHandleLocations	(	IProperty &	parent,
		const std::string &	prop,
		const std::vector< std::string > &	newLocs
	)

inline

Definition at line 32 of file FunctionalUtilities.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);
     }