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)
std::string	replace_all (std::string str, std::string_view from, std::string_view to)
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.
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 = typename arg_helper<lambda>::type

Definition at line 42 of file EventIDBase.h.

Converter_t

template<typename T>

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

Definition at line 26 of file DataObjectHandle.h.

Payload_t

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

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

Definition at line 90 of file DataObjectHandle.h.

ReadHandle

template<typename T, typename U = T>

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

Definition at line 438 of file DataObjectHandle.h.

WriteHandle

template<typename T, typename U = T>

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

Definition at line 436 of file DataObjectHandle.h.

Function Documentation

add_deref()

template<typename Fun>

auto details::add_deref

(

Fun

f

)

Definition at line 45 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 46 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 51 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 50 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 29 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 26 of file GaudiHandle.h.

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

replace_all()

std::string details::replace_all	(	std::string	str,
		std::string_view	from,
		std::string_view	to )

Definition at line 18 of file ReplaceAll.cpp.

                                                                                 {
    if ( from.empty() ) return str;
    boost::replace_all( str, from, to );
    return str;
  }

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 42 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>

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