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)
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)
const std::string &	inputLocation (unsigned int n) const
unsigned int	inputLocationSize () const
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< InputHandle_t< In > >	m_inputs
Gaudi::Property< std::vector< std::string > >	m_inputLocations

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 57 of file MergingTransformer.h.

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

Definition at line 26 of file MergingTransformer.h.

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

Definition at line 27 of file MergingTransformer.h.

template<typename Container >

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

Definition at line 9 of file ListTransformer.h.

template<typename Container >

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

Definition at line 21 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 11 of file ListTransformer.h.

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

StatusCode Gaudi::Functional::execute ( )

finaloverride

Definition at line 37 of file MergingTransformer.h.

                                          {
        vector_of_const_<In> ins;
        ins.reserve( m_inputs.size() );
        std::transform( m_inputs.begin(), m_inputs.end(), std::back_inserter( ins ),
                        details::details2::get_from_handle<In>{} );
        try {
          using details::as_const;
          details::put( std::get<0>( this->m_outputs ), as_const( *this )( as_const( ins ) ) );
        } catch ( GaudiException& e ) {
          ( e.code() ? this->warning() : this->error() ) << e.message() << endmsg;
          return e.code();
        }
        return StatusCode::SUCCESS;
      }

const std::string& Gaudi::Functional::inputLocation

(

unsigned int

n

)

const

Definition at line 33 of file MergingTransformer.h.

{ return m_inputLocations.value()[n]; }

unsigned int Gaudi::Functional::inputLocationSize

(

)

const

Definition at line 34 of file MergingTransformer.h.

{ return m_inputLocations.value().size(); }

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

Definition at line 65 of file MergingTransformer.h.

        : base_class( name, pSvcLocator, output )
        , m_inputLocations{this, inputs.first, inputs.second,
                           [=]( Gaudi::Details::PropertyBase& ) {
                             this->m_inputs =
                                 details::make_vector_of_handles<decltype( this->m_inputs )>( this, m_inputLocations );
                             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 ); } );
                             }
                           },
                           Gaudi::Details::Property::ImmediatelyInvokeHandler{true}} {}

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 );
    }

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

inline

Definition at line 43 of file FunctionalUtilities.h.

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

Variable Documentation

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

private

Definition at line 59 of file MergingTransformer.h.

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

private

Definition at line 58 of file MergingTransformer.h.

template<typename Out , typename In , typename Traits_ >

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

Initial value:

{
      using base_class = details::DataHandleMixin<std::tuple<Out>, void, Traits_>

Definition at line 21 of file MergingTransformer.h.

template<typename Out , typename In , typename Traits_ >

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

Definition at line 21 of file MergingTransformer.h.