| The Gaudi Framework v29r1 (5cd95fa2)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Public Member Functions | Private Types | List of all members
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 >:
[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 >
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 32 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 36 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 81 of file ContextSpecificPtr.h.

82 {
83 typedef typename std::result_of<Mapper( const T* )>::type R;
84 return accumulate( f, init, std::plus<R>() );
85 }
std::plus
std::result_of
Gaudi::Hive::ContextSpecificPtr::accumulate
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 t...
Definition: ContextSpecificPtr.h:81
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 92 of file ContextSpecificPtr.h.

93 {
94 typedef typename std::result_of<Mapper( const T* )>::type R;
95 typedef typename StorageType::value_type V;
96 std::lock_guard<std::mutex> lock( m_ptrs_lock );
97 return std::accumulate( m_ptrs.begin(), m_ptrs.end(), init, [&f, &op]( const R& partial, const V& p ) -> R {
98 return op( partial, f( p.second ) );
99 } );
100 }
std::unordered_map::end
T end(T...args)
Gaudi::Hive::ContextSpecificPtr::m_ptrs_lock
std::mutex m_ptrs_lock
Mutex for the m_ptrs container.
Definition: ContextSpecificPtr.h:144
std::result_of
std::lock
T lock(T...args)
std::lock_guard
std::unordered_map::begin
T begin(T...args)
Gaudi::Hive::ContextSpecificPtr::m_ptrs
StorageType m_ptrs
Internal storage for the different internal pointers.
Definition: ContextSpecificPtr.h:142
std::accumulate
T accumulate(T...args)
template<typename T>

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

Non thread-safe methods.

Set to null all the used pointers.

Definition at line 74 of file ContextSpecificPtr.h.

74 { 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:142
template<typename T>

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

Definition at line 132 of file ContextSpecificPtr.h.

133 {
134 for_each( []( T*& p ) {
135 delete p;
136 p = nullptr;
137 } );
138 }
Gaudi::Hive::ContextSpecificPtr::for_each
void for_each(F f) const
Call a function on each contained pointer.
Definition: ContextSpecificPtr.h:104
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 120 of file ContextSpecificPtr.h.

121 {
122 std::lock_guard<std::mutex> lock( m_ptrs_lock );
123 for ( auto& i : m_ptrs ) f( i.first, i.second );
124 }
Gaudi::Hive::ContextSpecificPtr::m_ptrs_lock
std::mutex m_ptrs_lock
Mutex for the m_ptrs container.
Definition: ContextSpecificPtr.h:144
std::lock
T lock(T...args)
std::lock_guard
Gaudi::Hive::ContextSpecificPtr::m_ptrs
StorageType m_ptrs
Internal storage for the different internal pointers.
Definition: ContextSpecificPtr.h:142
template<typename T>
template<class F >

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

Definition at line 126 of file ContextSpecificPtr.h.

127 {
128 std::lock_guard<std::mutex> lock( m_ptrs_lock );
129 for ( auto& i : m_ptrs ) f( i.first, i.second );
130 }
Gaudi::Hive::ContextSpecificPtr::m_ptrs_lock
std::mutex m_ptrs_lock
Mutex for the m_ptrs container.
Definition: ContextSpecificPtr.h:144
std::lock
T lock(T...args)
std::lock_guard
Gaudi::Hive::ContextSpecificPtr::m_ptrs
StorageType m_ptrs
Internal storage for the different internal pointers.
Definition: ContextSpecificPtr.h:142
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 104 of file ContextSpecificPtr.h.

105 {
106 std::lock_guard<std::mutex> lock( m_ptrs_lock );
107 for ( auto& i : m_ptrs ) f( i.second );
108 }
Gaudi::Hive::ContextSpecificPtr::m_ptrs_lock
std::mutex m_ptrs_lock
Mutex for the m_ptrs container.
Definition: ContextSpecificPtr.h:144
std::lock
T lock(T...args)
std::lock_guard
Gaudi::Hive::ContextSpecificPtr::m_ptrs
StorageType m_ptrs
Internal storage for the different internal pointers.
Definition: ContextSpecificPtr.h:142
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 112 of file ContextSpecificPtr.h.

113 {
114 std::lock_guard<std::mutex> lock( m_ptrs_lock );
115 for ( auto& i : m_ptrs ) f( i.second );
116 }
Gaudi::Hive::ContextSpecificPtr::m_ptrs_lock
std::mutex m_ptrs_lock
Mutex for the m_ptrs container.
Definition: ContextSpecificPtr.h:144
std::lock
T lock(T...args)
std::lock_guard
Gaudi::Hive::ContextSpecificPtr::m_ptrs
StorageType m_ptrs
Internal storage for the different internal pointers.
Definition: ContextSpecificPtr.h:142
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 40 of file ContextSpecificPtr.h.

41 {
42 std::lock_guard<std::mutex> lock( m_ptrs_lock );
43 return m_ptrs[currentContextId()];
44 }
Gaudi::Hive::currentContextId
GAUDI_API ContextIdType currentContextId()
Return the current context id.
Definition: ThreadLocalContext.cpp:22
Gaudi::Hive::ContextSpecificPtr::m_ptrs_lock
std::mutex m_ptrs_lock
Mutex for the m_ptrs container.
Definition: ContextSpecificPtr.h:144
std::lock
T lock(T...args)
std::lock_guard
Gaudi::Hive::ContextSpecificPtr::m_ptrs
StorageType m_ptrs
Internal storage for the different internal pointers.
Definition: ContextSpecificPtr.h:142
template<typename T>

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

Return true if the pointer is not null.

Definition at line 56 of file ContextSpecificPtr.h.

56 { return get(); }
template<typename T>

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

Conversion to boolean (.

See also
  isValid).

Definition at line 59 of file ContextSpecificPtr.h.

59 { return isValid(); }
Gaudi::Hive::ContextSpecificPtr::isValid
bool isValid() const
Return true if the pointer is not null.
Definition: ContextSpecificPtr.h:56
template<typename T>

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

Dereference operators.

Definition at line 65 of file ContextSpecificPtr.h.

65 { return *get(); }
template<typename T>

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

Definition at line 66 of file ContextSpecificPtr.h.

66 { return *get(); }
template<typename T>

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

Definition at line 67 of file ContextSpecificPtr.h.

67 { return get(); }
template<typename T>

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

Definition at line 68 of file ContextSpecificPtr.h.

68 { return get(); }
template<typename T>

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

Assignment operator (.

See also
  set).

Definition at line 53 of file ContextSpecificPtr.h.

53 { return set( ptr ); }
template<typename T>

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

Comparison with another pointer.

Definition at line 62 of file ContextSpecificPtr.h.

62 { 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 46 of file ContextSpecificPtr.h.

47 {
48 std::lock_guard<std::mutex> lock( m_ptrs_lock );
49 return m_ptrs[currentContextId()] = ptr;
50 }
Gaudi::Hive::currentContextId
GAUDI_API ContextIdType currentContextId()
Return the current context id.
Definition: ThreadLocalContext.cpp:22
Gaudi::Hive::ContextSpecificPtr::m_ptrs_lock
std::mutex m_ptrs_lock
Mutex for the m_ptrs container.
Definition: ContextSpecificPtr.h:144
std::lock
T lock(T...args)
std::lock_guard
Gaudi::Hive::ContextSpecificPtr::m_ptrs
StorageType m_ptrs
Internal storage for the different internal pointers.
Definition: ContextSpecificPtr.h:142

## Member Data Documentation

template<typename T>

StorageType Gaudi::Hive::ContextSpecificPtr< T >::m_ptrs
| mutable private

Internal storage for the different internal pointers.

Definition at line 142 of file ContextSpecificPtr.h.

template<typename T>

std::mutex Gaudi::Hive::ContextSpecificPtr< T >::m_ptrs_lock
| mutable private

Mutex for the m_ptrs container.

Definition at line 144 of file ContextSpecificPtr.h.

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

- GaudiKernel/GaudiKernel/ContextSpecificPtr.h