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 >
std::result_of< Mapper(const T *)>::type	accumulate (Mapper f, typename std::result_of< Mapper(const T *)>::type init) const
	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 >
std::result_of< Mapper(const T *)>::type	accumulate (Mapper f, typename std::result_of< Mapper(const T *)>::type init, BinaryOperation op) const
	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 >

std::result_of<Mapper(const T*)>::type Gaudi::Hive::ContextSpecificPtr< T >::accumulate	(	Mapper	f,
		typename std::result_of< Mapper(const T *)>::type	init
	)		const

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

                                                                                    {
         typedef typename std::result_of<Mapper(const T*)>::type R;
         return accumulate(f, init, std::plus<R>());
       }

template<typename T>

template<class Mapper , class BinaryOperation >

std::result_of<Mapper(const T*)>::type Gaudi::Hive::ContextSpecificPtr< T >::accumulate	(	Mapper	f,
		typename std::result_of< Mapper(const T *)>::type	init,
		BinaryOperation	op
	)		const

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

                                            {
         typedef typename std::result_of<Mapper(const T*)>::type R;
         typedef typename StorageType::value_type V;
         std::lock_guard<std::mutex> lock(m_ptrs_lock);
         return std::accumulate(m_ptrs.begin(), m_ptrs.end(), init,
           [&f, &op](const R& partial, const V& p) -> R {
           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.

69 { m_ptrs.clear(); }

std::unordered_map::clear

T clear(T...args)

Gaudi::Hive::ContextSpecificPtr::m_ptrs

StorageType m_ptrs

Internal storage for the different internal pointers.

Definition: ContextSpecificPtr.h:131

template<typename T>

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

inline

Definition at line 124 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 113 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 118 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 99 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 106 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.

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

54 { return isValid(); }

Gaudi::Hive::ContextSpecificPtr::isValid

bool isValid() const

Return true if the pointer is not null.

Definition: ContextSpecificPtr.h:51

template<typename T>

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

inline

Dereference operators.

Definition at line 60 of file ContextSpecificPtr.h.

60 { return *get(); }

template<typename T>

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

inline

Definition at line 61 of file ContextSpecificPtr.h.

61 { return *get(); }

template<typename T>

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

inline

Definition at line 62 of file ContextSpecificPtr.h.

62 { return get(); }

template<typename T>

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

inline

Definition at line 63 of file ContextSpecificPtr.h.

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

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

57 { 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 131 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 133 of file ContextSpecificPtr.h.

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

GaudiKernel/GaudiKernel/ContextSpecificPtr.h

Public Member Functions

Private Types

Detailed Description

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

Member Typedef Documentation

Member Function Documentation

Member Data Documentation

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