details Namespace Reference

Classes
struct	arg_helper
struct	arg_helper< Ret(T::*)(Arg) const >
class	GenericDataStoreAgent
struct	Payload_helper
struct	Payload_helper< Gaudi::DataHandle::Reader, Gaudi::NamedRange_< T >, U >
struct	Payload_helper< Gaudi::DataHandle::Reader, Gaudi::Range_< T >, U >
struct	Payload_helper< Gaudi::DataHandle::Reader, std::optional< Gaudi::NamedRange_< T > >, U >
struct	reverse_wrapper

Typedefs
template<typename T >
using	Converter_t = T(*)(const DataObject *)
template<Gaudi::DataHandle::Mode mode, typename T , typename U = T>
using	Payload_t = typename Payload_helper< mode, T, U >::type
template<typename T , typename U = T>
using	WriteHandle = DataObjectHandle< Payload_t< Gaudi::DataHandle::Writer, T, U > >
template<typename T , typename U = T>
using	ReadHandle = DataObjectHandle< Payload_t< Gaudi::DataHandle::Reader, T, U > >
template<typename lambda >
using	argument_t = typename arg_helper< lambda >::type

Functions
template<typename T , typename... Args>
constexpr auto	size (const T &, Args &&...) noexcept
template<typename Range , typename StorageType >
Range	make_range (const DataObject *obj)
template<typename ValueType , typename Range = Gaudi::Range_<typename ValueType::ConstVector>>
Converter_t< Range >	select_range_converter (const DataObject *obj)
template<typename T >
bool	verifyType (const DataObject *dataObj)
template<typename Fun >
auto	add_deref (Fun f)
template<typename Proj , typename Cmp = std::greater<>>
auto	make_cmp (Proj p, Cmp cmp={})
template<class T >
std::remove_const_t< T > *	nonConst (T *p)
	Cast a pointer to a non const type. More...
template<typename T >
auto	begin (reverse_wrapper< T > &w)
template<typename T >
auto	end (reverse_wrapper< T > &w)

Typedef Documentation

argument_t

template<typename lambda >

using details::argument_t = typedef typename arg_helper<lambda>::type

Definition at line 43 of file EventIDBase.h.

Converter_t

template<typename T >

using details::Converter_t = typedef T ( * )( const DataObject* )

Definition at line 27 of file DataObjectHandle.h.

Payload_t

template<Gaudi::DataHandle::Mode mode, typename T , typename U = T>

using details::Payload_t = typedef typename Payload_helper<mode, T, U>::type

Definition at line 91 of file DataObjectHandle.h.

ReadHandle

template<typename T , typename U = T>

using details::ReadHandle = typedef DataObjectHandle<Payload_t<Gaudi::DataHandle::Reader, T, U> >

Definition at line 448 of file DataObjectHandle.h.

WriteHandle

template<typename T , typename U = T>

using details::WriteHandle = typedef DataObjectHandle<Payload_t<Gaudi::DataHandle::Writer, T, U> >

Definition at line 446 of file DataObjectHandle.h.

Function Documentation

add_deref()

template<typename Fun >

auto details::add_deref

(

Fun

f

)

Definition at line 46 of file EventIDBase.h.

                          {
    return compose( f, [=]( auto*... p ) { return f( *p... ); } );
  }

begin()

template<typename T >

auto details::begin

(

reverse_wrapper< T > &

w

)

Definition at line 47 of file reverse.h.

                                      {
    using std::rbegin;
    return rbegin( w.iterable );
  }

end()

template<typename T >

auto details::end

(

reverse_wrapper< T > &

w

)

Definition at line 52 of file reverse.h.

                                    {
    using std::rend;
    return rend( w.iterable );
  }

make_cmp()

template<typename Proj , typename Cmp = std::greater<>>

auto details::make_cmp	(	Proj	p,
		Cmp	cmp = {}
	)

Definition at line 51 of file EventIDBase.h.

                                   {} ) {
    static_assert( std::is_reference_v<argument_t<Proj>>, "must be a reference" );
    static_assert( std::is_const_v<std::remove_reference_t<argument_t<Proj>>>, "must be const" );
    return [=]( argument_t<Proj> lhs, argument_t<Proj> rhs ) { return cmp( p( lhs ), p( rhs ) ); };
  }

make_range()

template<typename Range , typename StorageType >

Range details::make_range

(

const DataObject *

obj

)

Definition at line 30 of file DataObjectHandle.h.

                                            {
    auto c = static_cast<const StorageType*>( obj );
    if ( !c ) return Range();
    using std::begin;
    using std::end;
    auto first  = begin( *c );
    auto last   = end( *c );
    auto _first = reinterpret_cast<typename Range::const_iterator*>( &first );
    auto _last  = reinterpret_cast<typename Range::const_iterator*>( &last );
    return Range( *_first, *_last );
  }

nonConst()

template<class T >

std::remove_const_t<T>* details::nonConst

(

T *

p

)

Cast a pointer to a non const type.

Definition at line 29 of file GaudiHandle.h.

                                         {
    return const_cast<std::remove_const_t<T>*>( p );
  }

select_range_converter()

template<typename ValueType , typename Range = Gaudi::Range_<typename ValueType::ConstVector>>

Converter_t<Range> details::select_range_converter

(

const DataObject *

obj

)

Definition at line 43 of file DataObjectHandle.h.

                                                                     {
    using Selection = typename ValueType::Selection;
    auto sel        = dynamic_cast<const Selection*>( obj );
    if ( sel ) return &make_range<Range, typename ValueType::Selection>;
    auto con = dynamic_cast<std::add_const_t<typename ValueType::Container>*>( obj );
    if ( con ) return &make_range<Range, typename ValueType::Container>;
    return nullptr;
  }

size()

template<typename T , typename... Args>

constexpr auto details::size ( const T &  , Args &&  ...  )

constexprnoexcept

Definition at line 23 of file AnyDataWrapper.h.

                                                      {
    static_assert( sizeof...( Args ) == 0, "No extra args please" );
    return std::nullopt;
  }

verifyType()

template<typename T >

bool details::verifyType

(

const DataObject *

dataObj

)

Definition at line 53 of file DataObjectHandle.h.

                                               {
    using Type = std::add_const_t<T>;
    assert( dataObj != nullptr );
    auto obj = dynamic_cast<Type*>( dataObj );
    bool ok  = ( obj != nullptr );
    if ( !ok ) {
      const auto* registry = dataObj->registry();
      throw GaudiException( "The type expected for " + registry->identifier() + " is " +
                                System::typeinfoName( typeid( Type ) ) +
                                " and is different from the one of the object in the store which is " +
                                System::typeinfoName( typeid( *dataObj ) ) + ".",
                            "Wrong DataObjectType", StatusCode::FAILURE );
    }
    assert( obj == static_cast<Type*>( dataObj ) );
    return ok;
  }