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

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

#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 30 of file ContextSpecificPtr.h.

Member Typedef Documentation

template<typename T>

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

private

Type used for the internal storage.

Definition at line 33 of file ContextSpecificPtr.h.

Member Function Documentation

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 75 of file ContextSpecificPtr.h.

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

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 83 of file ContextSpecificPtr.h.

                              {
        std::lock_guard<std::mutex> 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 ) );
        } );
      }

template<typename T>

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

inline

Non thread-safe methods.

Set to null all the used pointers.

Definition at line 69 of file ContextSpecificPtr.h.

{ m_ptrs.clear(); }

template<typename T>

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

inline

Definition at line 117 of file ContextSpecificPtr.h.

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

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 107 of file ContextSpecificPtr.h.

                                {
        std::lock_guard<std::mutex> lock( m_ptrs_lock );
        for ( auto& i : m_ptrs ) f( i.first, i.second );
      }

template<typename T>

template<class F >

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

inline

Definition at line 112 of file ContextSpecificPtr.h.

                          {
        std::lock_guard<std::mutex> lock( m_ptrs_lock );
        for ( auto& i : m_ptrs ) f( i.first, i.second );
      }

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 93 of file ContextSpecificPtr.h.

                                 {
        std::lock_guard<std::mutex> lock( m_ptrs_lock );
        for ( auto& i : m_ptrs ) f( i.second );
      }

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 100 of file ContextSpecificPtr.h.

                           {
        std::lock_guard<std::mutex> lock( m_ptrs_lock );
        for ( auto& i : m_ptrs ) f( i.second );
      }

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 37 of file ContextSpecificPtr.h.

                            {
        std::lock_guard<std::mutex> lock( m_ptrs_lock );
        return m_ptrs[currentContextId()];
      }

template<typename T>

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

inline

Return true if the pointer is not null.

Definition at line 51 of file ContextSpecificPtr.h.

{ return get(); }

template<typename T>

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

inline

Conversion to boolean (.

See also

isValid).

Definition at line 54 of file ContextSpecificPtr.h.

{ return isValid(); }

template<typename T>

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

inline

Dereference operators.

Definition at line 60 of file ContextSpecificPtr.h.

{ return *get(); }

template<typename T>

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

inline

Definition at line 61 of file ContextSpecificPtr.h.

{ return *get(); }

template<typename T>

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

inline

Definition at line 62 of file ContextSpecificPtr.h.

{ return get(); }

template<typename T>

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

inline

Definition at line 63 of file ContextSpecificPtr.h.

{ return get(); }

template<typename T>

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

inline

Assignment operator (.

See also

set).

Definition at line 48 of file ContextSpecificPtr.h.

{ return set( ptr ); }

template<typename T>

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

inline

Comparison with another pointer.

Definition at line 57 of file ContextSpecificPtr.h.

{ return get() == rhs; }

template<typename T>

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

inline

Set the pointer for the current context.

Definition at line 42 of file ContextSpecificPtr.h.

                               {
        std::lock_guard<std::mutex> lock( m_ptrs_lock );
        return m_ptrs[currentContextId()] = ptr;
      }

Member Data Documentation

template<typename T>

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

mutableprivate

Internal storage for the different internal pointers.

Definition at line 126 of file ContextSpecificPtr.h.

template<typename T>

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

mutableprivate

Mutex for the m_ptrs container.

Definition at line 128 of file ContextSpecificPtr.h.

---

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

• GaudiKernel/GaudiKernel/ContextSpecificPtr.h