ExpressionParsing::PointerCache< T, MEMORY_ORDER > Class Template Reference

Helper class to cache a non owning or owning pointer in an atomic way. More...

#include <PointerCache.h>

Collaboration diagram for ExpressionParsing::PointerCache< T, MEMORY_ORDER >:

Public Member Functions
	PointerCache ()=default
	~PointerCache ()
void	setIfUnset (const T &obj)
	set a pointer without handing over ownership
void	setIfUnset (std::unique_ptr< T > &&ptr)
	set a pointer andhand over ownership
	operator bool () const
	set whether a valid pointer is set
const T *	operator-> () const
	dereference the pointer

Private Member Functions
void	setPointer (const T *ptr, bool owner)

Private Attributes
std::atomic< const T * >	m_ptr
std::atomic< bool >	m_owner

Detailed Description

template<class T, std::memory_order MEMORY_ORDER>
class ExpressionParsing::PointerCache< T, MEMORY_ORDER >

Helper class to cache a non owning or owning pointer in an atomic way.

Definition at line 12 of file PointerCache.h.

Constructor & Destructor Documentation

PointerCache()

template<class T, std::memory_order MEMORY_ORDER>

ExpressionParsing::PointerCache< T, MEMORY_ORDER >::PointerCache ( )

default

~PointerCache()

template<class T, std::memory_order MEMORY_ORDER>

ExpressionParsing::PointerCache< T, MEMORY_ORDER >::~PointerCache ( )

inline

Definition at line 16 of file PointerCache.h.

                      {
         if (m_owner) {
            delete m_ptr.load();
         }
      }

Member Function Documentation

operator bool()

template<class T, std::memory_order MEMORY_ORDER>

ExpressionParsing::PointerCache< T, MEMORY_ORDER >::operator bool ( ) const

inline

set whether a valid pointer is set

Definition at line 31 of file PointerCache.h.

                            {
         return m_ptr != nullptr;
      }

operator->()

template<class T, std::memory_order MEMORY_ORDER>

const T * ExpressionParsing::PointerCache< T, MEMORY_ORDER >::operator-> ( ) const

inline

dereference the pointer

Note

result is undefined if the pointer was not set and points to a valid object of type T

Definition at line 36 of file PointerCache.h.

                                  {
         assert (m_ptr);
         return m_ptr.load(MEMORY_ORDER);
      }

setIfUnset() [1/2]

template<class T, std::memory_order MEMORY_ORDER>

void ExpressionParsing::PointerCache< T, MEMORY_ORDER >::setIfUnset ( const T & obj )

inline

set a pointer without handing over ownership

Definition at line 23 of file PointerCache.h.

                                    {
         setPointer(&obj, false);
      }

setIfUnset() [2/2]

template<class T, std::memory_order MEMORY_ORDER>

void ExpressionParsing::PointerCache< T, MEMORY_ORDER >::setIfUnset ( std::unique_ptr< T > && ptr )

inline

set a pointer andhand over ownership

Definition at line 27 of file PointerCache.h.

                                              {
         setPointer(ptr.release(), true);
      }

setPointer()

template<class T, std::memory_order MEMORY_ORDER>

void ExpressionParsing::PointerCache< T, MEMORY_ORDER >::setPointer ( const T * ptr, bool owner )

inlineprivate

Definition at line 42 of file PointerCache.h.

                                                {
         while (m_ptr == nullptr) {
            const T *expected=nullptr;
            if (m_ptr.compare_exchange_weak(expected, ptr, MEMORY_ORDER)) break;
         }
         if (m_ptr == ptr) {
            m_owner = owner;
         }
         else {
            if (owner) {
               delete ptr;
            }
         }
      }

Member Data Documentation

m_owner

template<class T, std::memory_order MEMORY_ORDER>

std::atomic<bool> ExpressionParsing::PointerCache< T, MEMORY_ORDER >::m_owner

private

Definition at line 57 of file PointerCache.h.

m_ptr

template<class T, std::memory_order MEMORY_ORDER>

std::atomic<const T *> ExpressionParsing::PointerCache< T, MEMORY_ORDER >::m_ptr

private

Definition at line 56 of file PointerCache.h.

---

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

• PointerCache.h