Gaudi::Hive::ContextSpecificPtr< T > Class Template Reference

Simple implementation of a smart pointer with different values for different event contexts (slots). More...

#include </builds/gaudi/Gaudi/GaudiKernel/include/GaudiKernel/ContextSpecificPtr.h>

Collaboration diagram for Gaudi::Hive::ContextSpecificPtr< T >:

Public Member Functions
T *	get () const
	Return the pointer for the current context (null for a new context). More...
T *&	set (T *ptr)
	Set the pointer for the current context. More...
T *&	operator= (T *ptr)
	Assignment operator (. More...
bool	isValid () const
	Return true if the pointer is not null. More...
	operator bool () const
	Conversion to boolean (. More...
bool	operator== (T *rhs) const
	Comparison with another pointer. More...
T &	operator* ()
	Dereference operators. More...
const T &	operator* () const
T *	operator-> ()
const T *	operator-> () const

Private Types
typedef std::unordered_map< ContextIdType, T * >	StorageType
	Type used for the internal storage. More...
StorageType	m_ptrs
	Internal storage for the different internal pointers. More...
std::mutex	m_ptrs_lock
	Mutex for the m_ptrs container. More...
void	clear ()
	Non thread-safe methods. More...
template<class Mapper >
auto	accumulate (Mapper f, std::result_of_t< Mapper(const T *)> init) const -> decltype(init)
	Taking a function f that from a T* produces a value, return the sum of all the values corresponding to the contained pointers using init as first value. More...
template<class Mapper , class BinaryOperation >
auto	accumulate (Mapper f, std::result_of_t< Mapper(const T *)> init, BinaryOperation op) const -> decltype(init)
	Taking a function f that from a T* produces a value, return the accumulated result, through the operation 'op', of all the values corresponding to the contained pointers using init as first value. More...
template<class F >
void	for_each (F f) const
	Call a function on each contained pointer. More...
template<class F >
void	for_each (F f)
	Call a function on each contained pointer. (non-const version) More...
template<class F >
void	for_all (F f) const
	Call a function on each element, passing slot# as well. More...
template<class F >
void	for_all (F f)
void	deleteAll ()

Detailed Description

template<typename T>
class Gaudi::Hive::ContextSpecificPtr< T >

Simple implementation of a smart pointer with different values for different event contexts (slots).

When the copy for a new context is requested, the returned pointer is null.

The interface is meant to allow for a drop-in replacement for regular pointers. It's still responsibility of the user to delete the memory associated to the pointers.

Definition at line 40 of file ContextSpecificPtr.h.

Member Typedef Documentation

StorageType

template<typename T >

typedef std::unordered_map<ContextIdType, T*> Gaudi::Hive::ContextSpecificPtr< T >::StorageType

private

Type used for the internal storage.

Definition at line 43 of file ContextSpecificPtr.h.

Member Function Documentation

accumulate() [1/2]

template<typename T >

template<class Mapper >

auto Gaudi::Hive::ContextSpecificPtr< T >::accumulate ( Mapper  f, std::result_of_t< Mapper(const T *)>  init  ) const -> decltype( init )

inline

Taking a function f that from a T* produces a value, return the sum of all the values corresponding to the contained pointers using init as first value.

Definition at line 88 of file ContextSpecificPtr.h.

                                                                                                     {
#endif
        return accumulate( f, init, std::plus<>() );
      }

accumulate() [2/2]

template<typename T >

template<class Mapper , class BinaryOperation >

auto Gaudi::Hive::ContextSpecificPtr< T >::accumulate ( Mapper  f, std::result_of_t< Mapper(const T *)>  init, BinaryOperation  op  ) const -> decltype( init )

inline

Taking a function f that from a T* produces a value, return the accumulated result, through the operation 'op', of all the values corresponding to the contained pointers using init as first value.

Definition at line 100 of file ContextSpecificPtr.h.

                              {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        return std::accumulate( m_ptrs.begin(), m_ptrs.end(), init, [&f, &op]( const auto& partial, const auto& p ) {
          return op( partial, f( p.second ) );
        } );
      }

clear()

template<typename T >

void Gaudi::Hive::ContextSpecificPtr< T >::clear ( )

inline

Non thread-safe methods.

Set to null all the used pointers.

Definition at line 79 of file ContextSpecificPtr.h.

{ m_ptrs.clear(); }

deleteAll()

template<typename T >

void Gaudi::Hive::ContextSpecificPtr< T >::deleteAll ( )

inline

Definition at line 135 of file ContextSpecificPtr.h.

                       {
        for_each( []( T*& p ) {
          delete p;
          p = nullptr;
        } );
      }

for_all() [1/2]

template<typename T >

template<class F >

void Gaudi::Hive::ContextSpecificPtr< T >::for_all ( F  f )

inline

Definition at line 130 of file ContextSpecificPtr.h.

                          {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        for ( auto& i : m_ptrs ) f( i.first, i.second );
      }

for_all() [2/2]

template<typename T >

template<class F >

void Gaudi::Hive::ContextSpecificPtr< T >::for_all ( F  f ) const

inline

Call a function on each element, passing slot# as well.

Definition at line 125 of file ContextSpecificPtr.h.

                                {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        for ( auto& i : m_ptrs ) f( i.first, i.second );
      }

for_each() [1/2]

template<typename T >

template<class F >

void Gaudi::Hive::ContextSpecificPtr< T >::for_each ( F  f )

inline

Call a function on each contained pointer. (non-const version)

Definition at line 118 of file ContextSpecificPtr.h.

                           {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        for ( auto& i : m_ptrs ) f( i.second );
      }

for_each() [2/2]

template<typename T >

template<class F >

void Gaudi::Hive::ContextSpecificPtr< T >::for_each ( F  f ) const

inline

Call a function on each contained pointer.

Definition at line 111 of file ContextSpecificPtr.h.

                                 {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        for ( auto& i : m_ptrs ) f( i.second );
      }

get()

template<typename T >

T* Gaudi::Hive::ContextSpecificPtr< T >::get ( ) const

inline

Return the pointer for the current context (null for a new context).

Definition at line 47 of file ContextSpecificPtr.h.

                     {
        auto lock = std::scoped_lock{ m_ptrs_lock };
        return m_ptrs[currentContextId()];
      }

isValid()

template<typename T >

bool Gaudi::Hive::ContextSpecificPtr< T >::isValid ( ) const

inline

Return true if the pointer is not null.

Definition at line 61 of file ContextSpecificPtr.h.

{ return get(); }

operator bool()

template<typename T >

Gaudi::Hive::ContextSpecificPtr< T >::operator bool ( ) const

inline

Conversion to boolean (.

See also

isValid).

Definition at line 64 of file ContextSpecificPtr.h.

{ return isValid(); }

operator*() [1/2]

template<typename T >

T& Gaudi::Hive::ContextSpecificPtr< T >::operator* ( )

inline

Dereference operators.

Definition at line 70 of file ContextSpecificPtr.h.

{ return *get(); }

operator*() [2/2]

template<typename T >

const T& Gaudi::Hive::ContextSpecificPtr< T >::operator* ( ) const

inline

Definition at line 71 of file ContextSpecificPtr.h.

{ return *get(); }

operator->() [1/2]

template<typename T >

T* Gaudi::Hive::ContextSpecificPtr< T >::operator-> ( )

inline

Definition at line 72 of file ContextSpecificPtr.h.

{ return get(); }

operator->() [2/2]

template<typename T >

const T* Gaudi::Hive::ContextSpecificPtr< T >::operator-> ( ) const

inline

Definition at line 73 of file ContextSpecificPtr.h.

{ return get(); }

operator=()

template<typename T >

T*& Gaudi::Hive::ContextSpecificPtr< T >::operator= ( T *  ptr )

inline

Assignment operator (.

See also

set).

Definition at line 58 of file ContextSpecificPtr.h.

{ return set( ptr ); }

operator==()

template<typename T >

bool Gaudi::Hive::ContextSpecificPtr< T >::operator== ( T *  rhs ) const

inline

Comparison with another pointer.

Definition at line 67 of file ContextSpecificPtr.h.

{ return get() == rhs; }

set()

template<typename T >

T*& Gaudi::Hive::ContextSpecificPtr< T >::set ( T *  ptr )

inline

Set the pointer for the current context.

Definition at line 52 of file ContextSpecificPtr.h.

                        {
        auto lock                         = std::scoped_lock{ m_ptrs_lock };
        return m_ptrs[currentContextId()] = ptr;
      }

Member Data Documentation

m_ptrs

template<typename T >

StorageType Gaudi::Hive::ContextSpecificPtr< T >::m_ptrs

mutableprivate

Internal storage for the different internal pointers.

Definition at line 144 of file ContextSpecificPtr.h.

m_ptrs_lock

template<typename T >

std::mutex Gaudi::Hive::ContextSpecificPtr< T >::m_ptrs_lock

mutableprivate

Mutex for the m_ptrs container.

Definition at line 146 of file ContextSpecificPtr.h.

---

The documentation for this class was generated from the following file:

• GaudiKernel/include/GaudiKernel/ContextSpecificPtr.h