details Namespace Reference

Classes
struct	arg_helper
struct	arg_helper< Ret(T::*)(Arg) const >
struct	Payload_helper
struct	Payload_helper< Gaudi::Range_< T > >
struct	reverse_wrapper

Typedefs
template<typename T >
using	Converter_t = T(*)(const DataObject *)
template<typename T >
using	Payload_t = typename Payload_helper< T >::type
template<typename lambda >
using	argument_t = typename arg_helper< lambda >::type

Functions
template<typename C >
constexpr auto	size (const C &c) noexcept(noexcept(c.size())) -> decltype(c.size())
template<typename T , std::size_t N>
constexpr auto	size (const T(&array)[N]) noexcept
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

template<typename lambda >

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

Definition at line 35 of file EventIDBase.h.

template<typename T >

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

Definition at line 19 of file DataObjectHandle.h.

template<typename T >

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

Definition at line 75 of file DataObjectHandle.h.

Function Documentation

template<typename Fun >

auto details::add_deref

(

Fun

f

)

Definition at line 38 of file EventIDBase.h.

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

template<typename T >

auto details::begin

(

reverse_wrapper< T > &

w

)

Definition at line 38 of file reverse.h.

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

template<typename T >

auto details::end

(

reverse_wrapper< T > &

w

)

Definition at line 44 of file reverse.h.

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

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

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

Definition at line 44 of file EventIDBase.h.

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

template<typename Range , typename StorageType >

Range details::make_range

(

const DataObject *

obj

)

Definition at line 22 of file DataObjectHandle.h.

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

template<class T >

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

(

T *

p

)

Cast a pointer to a non const type.

Definition at line 21 of file GaudiHandle.h.

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

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

Converter_t<Range> details::select_range_converter

(

const DataObject *

obj

)

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

template<typename C >

constexpr auto details::size ( const C &  c ) -> decltype( c.size() )

noexcept

Definition at line 14 of file AnyDataWrapper.h.

  {
    return c.size();
  }

template<typename T , std::size_t N>

constexpr auto details::size ( const T(&)  array[N] )

noexcept

Definition at line 20 of file AnyDataWrapper.h.

  {
    return N;
  }

template<typename T , typename... Args>

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

noexcept

Definition at line 29 of file AnyDataWrapper.h.

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

template<typename T >

bool details::verifyType

(

const DataObject *

dataObj

)

Definition at line 48 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.",
                            "Wrong DataObjectType", StatusCode::FAILURE );
    }
    assert( obj == static_cast<Type*>( dataObj ) );
    return ok;
  }