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

Implementation of a context specific storage accessible as a sort of smart reference class. More...

#include <GaudiKernel/ContextSpecificPtr.h>

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

Public Member Functions
	ContextSpecificData ()
	Constructor with default initialization. More...
	ContextSpecificData (const T &proto)
	Constructor with prototype value. More...
	~ContextSpecificData ()
	Destructor. More...
	operator T & ()
	operator T & () const
T &	operator= (const T &other)
	Assignment operator. More...
T	accumulate (T init) const
	Return the sum of all the contained values using init as first value. More...
template<class T1 , class BinaryOperation >
T1	accumulate (T1 init, BinaryOperation op) const
	Return the accumulated result, through the operation 'op', of all the contained values using init as first value. More...
template<class F >
void	for_each (F f) const
	Call a function on each contained value. More...
template<class F >
void	for_each (F f)
	Call a function on each contained value. (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)

Private Member Functions
	ContextSpecificData (const ContextSpecificData &)=delete

Private Attributes
T	m_proto
	Prototype value. More...
ContextSpecificPtr< T >	m_ptr
	Internal implementation. More...

Detailed Description

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

Implementation of a context specific storage accessible as a sort of smart reference class.

New values are created from the prototype passed to the constructor.

Definition at line 144 of file ContextSpecificPtr.h.

Constructor & Destructor Documentation

template<typename T>

Gaudi::Hive::ContextSpecificData< T >::ContextSpecificData ( )

inline

Constructor with default initialization.

Definition at line 147 of file ContextSpecificPtr.h.

: m_proto() {}

template<typename T>

Gaudi::Hive::ContextSpecificData< T >::ContextSpecificData ( const T &  proto )

inline

Constructor with prototype value.

Definition at line 149 of file ContextSpecificPtr.h.

: m_proto(proto) {}

template<typename T>

Gaudi::Hive::ContextSpecificData< T >::~ContextSpecificData ( )

inline

Destructor.

Definition at line 152 of file ContextSpecificPtr.h.

                             {
        m_ptr.deleteAll();
      }

template<typename T>

Gaudi::Hive::ContextSpecificData< T >::ContextSpecificData ( const ContextSpecificData< T > &  )

privatedelete

Member Function Documentation

template<typename T>

T Gaudi::Hive::ContextSpecificData< T >::accumulate ( T  init ) const

inline

Return the sum of all the contained values using init as first value.

Definition at line 176 of file ContextSpecificPtr.h.

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

template<typename T>

template<class T1 , class BinaryOperation >

T1 Gaudi::Hive::ContextSpecificData< T >::accumulate ( T1  init, BinaryOperation  op  ) const

inline

Return the accumulated result, through the operation 'op', of all the contained values using init as first value.

Definition at line 183 of file ContextSpecificPtr.h.

                                                       {
        return m_ptr.accumulate([] (const T* p) -> T { return *p; },
                                init, op);
      }

template<typename T>

template<class F >

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

inline

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

Definition at line 202 of file ContextSpecificPtr.h.

                              {
        m_ptr.for_all([&f] (size_t s, const T* p) { f(s,*p); });
      }

template<typename T>

template<class F >

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

inline

Definition at line 206 of file ContextSpecificPtr.h.

                        {
        m_ptr.for_all([&f] (size_t s, T* p) { f(s,*p); });
      }      

template<typename T>

template<class F >

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

inline

Call a function on each contained value.

Definition at line 190 of file ContextSpecificPtr.h.

                               {
        m_ptr.for_each([&f] (const T* p) { f(*p); });
      }

template<typename T>

template<class F >

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

inline

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

Definition at line 196 of file ContextSpecificPtr.h.

                         {
        m_ptr.for_each([&f] (T* p) { f(*p); });
      }

template<typename T>

Gaudi::Hive::ContextSpecificData< T >::operator T & ( )

inline

Definition at line 156 of file ContextSpecificPtr.h.

                            {
        if (m_ptr)
          return *m_ptr;
        else
          return *(m_ptr = new T(m_proto));
      }

template<typename T>

Gaudi::Hive::ContextSpecificData< T >::operator T & ( ) const

inline

Definition at line 163 of file ContextSpecificPtr.h.

                                  {
        if (m_ptr)
          return *m_ptr;
        else
          return *(m_ptr = new T(m_proto));
      }

template<typename T>

T& Gaudi::Hive::ContextSpecificData< T >::operator= ( const T &  other )

inline

Assignment operator.

Definition at line 171 of file ContextSpecificPtr.h.

                                           {
        return (T&)(*this) = other;
      }

Member Data Documentation

template<typename T>

T Gaudi::Hive::ContextSpecificData< T >::m_proto

private

Prototype value.

Definition at line 217 of file ContextSpecificPtr.h.

template<typename T>

ContextSpecificPtr<T> Gaudi::Hive::ContextSpecificData< T >::m_ptr

mutableprivate

Internal implementation.

Definition at line 219 of file ContextSpecificPtr.h.

---

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

• GaudiKernel/GaudiKernel/ContextSpecificPtr.h