Gaudi::Functional Namespace Reference

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)
	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 Signature , typename Traits_ = Traits::useDefaults>
struct[[deprecated("use MergingTransformer instead")]]	ListTransformer
template<typename Signature , typename Traits_ = Traits::useDefaults>
struct[[deprecated("use MergingTransformer instead")]]	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 43 of file MergingTransformer.h.

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

Definition at line 29 of file MergingTransformer.h.

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

Definition at line 30 of file MergingTransformer.h.

template<typename Container >

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

Definition at line 11 of file ListTransformer.h.

template<typename Container >

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

Definition at line 22 of file SplittingTransformer.h.

Function Documentation

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

inline

Definition at line 21 of file FunctionalUtilities.h.

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

template<typename... Strings>

std::string Gaudi::Functional::concat_alternatives

(

const Strings &...

s

)

Definition at line 27 of file FunctionalUtilities.h.

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

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 49 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 32 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 38 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 );
    }

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

inline

Definition at line 50 of file FunctionalUtilities.h.

    {
      return updateHandleLocation( parent, prop, newLoc );
    }

Variable Documentation

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

struct [[deprecated( "use MergingTransformer instead" )]] Gaudi::Functional::ListTransformer

Definition at line 13 of file ListTransformer.h.

std::vector<std::string> Gaudi::Functional::m_inputLocations

private

Definition at line 44 of file MergingTransformer.h.

std::vector<InputHandle_t<In> > Gaudi::Functional::m_inputs

private

Definition at line 45 of file MergingTransformer.h.

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

class MergingTransformer< Out(const vector_of_const_< In > Gaudi::Functional::Traits_

Initial value:

{
      using MergingTransformer<Signature, Traits_>::MergingTransformer

Definition at line 14 of file ListTransformer.h.

template<typename Out , typename In , typename Traits_ >

class MergingTransformer< Out(const vector_of_const_< In > Gaudi::Functional::void

Definition at line 23 of file MergingTransformer.h.