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

[legend]

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.

79 { 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.

61 { 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.

64 { 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.

70 { 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.

71 { return *get(); }

◆ operator->() [1/2]

template<typename T >

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

inline

Definition at line 72 of file ContextSpecificPtr.h.

72 { 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.

73 { 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.

58 { 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.

67 { 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

Public Member Functions

Private Types

Detailed Description

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

Member Typedef Documentation

◆ StorageType

Member Function Documentation

◆ accumulate() [1/2]

◆ accumulate() [2/2]

◆ clear()

◆ deleteAll()

◆ for_all() [1/2]

◆ for_all() [2/2]

◆ for_each() [1/2]

◆ for_each() [2/2]

◆ get()

◆ isValid()

◆ operator bool()

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator->() [1/2]

◆ operator->() [2/2]

◆ operator=()

◆ operator==()

◆ set()

Member Data Documentation

◆ m_ptrs

◆ m_ptrs_lock

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