duckdb::atomic_ptr< T, SAFE > Class Template Reference

Collaboration diagram for duckdb::atomic_ptr< T, SAFE >:

Public Member Functions
	atomic_ptr (T *ptr_p)
	atomic_ptr (T &ref)
	atomic_ptr (const unique_ptr< T > &ptr_p)
	atomic_ptr (const shared_ptr< T > &ptr_p)
void	CheckValid (const T *ptr) const
T *	GetPointer ()
const T *	GetPointer () const
	operator bool () const
T &	operator* ()
const T &	operator* () const
T *	operator-> ()
const T *	operator-> () const
T *	get ()
const T *	get () const
T *	get_mutable () const
void	set (T &ref)
void	reset ()
bool	operator== (const atomic_ptr< T > &rhs) const
bool	operator!= (const atomic_ptr< T > &rhs) const

Private Attributes
atomic< T * >	ptr

Constructor & Destructor Documentation

atomic_ptr() [1/5]

template<class T , bool SAFE = true>

duckdb::atomic_ptr< T, SAFE >::atomic_ptr ( )

inlinenoexcept

                          : ptr(nullptr) {
    }

atomic_ptr() [2/5]

template<class T , bool SAFE = true>

duckdb::atomic_ptr< T, SAFE >::atomic_ptr ( T *  ptr_p )

inline

                         : ptr(ptr_p) { // NOLINT: allow implicit creation from pointer
    }

atomic_ptr() [3/5]

template<class T , bool SAFE = true>

duckdb::atomic_ptr< T, SAFE >::atomic_ptr ( T &  ref )

inline

                       : ptr(&ref) { // NOLINT: allow implicit creation from reference
    }

atomic_ptr() [4/5]

template<class T , bool SAFE = true>

duckdb::atomic_ptr< T, SAFE >::atomic_ptr ( const unique_ptr< T > &  ptr_p )

inline

                                           : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from unique pointer
    }

atomic_ptr() [5/5]

template<class T , bool SAFE = true>

duckdb::atomic_ptr< T, SAFE >::atomic_ptr ( const shared_ptr< T > &  ptr_p )

inline

                                           : ptr(ptr_p.get()) { // NOLINT: allow implicit creation from shared pointer
    }

Member Function Documentation

CheckValid()

template<class T , bool SAFE = true>

void duckdb::atomic_ptr< T, SAFE >::CheckValid ( const T *  ptr ) const

inline

                                        {
        if (MemorySafety<SAFE>::ENABLED) {
            return;
        }
        if (!ptr) {
            throw InternalException("Attempting to dereference an optional pointer that is not set");
        }
    }

GetPointer() [1/2]

template<class T , bool SAFE = true>

T * duckdb::atomic_ptr< T, SAFE >::GetPointer ( )

inline

                    {
        auto res = ptr.load();
        CheckValid(res);
        return res;
    }

GetPointer() [2/2]

template<class T , bool SAFE = true>

const T * duckdb::atomic_ptr< T, SAFE >::GetPointer ( ) const

inline

                                {
        auto res = ptr.load();
        CheckValid(res);
        return res;
    }

operator bool()

template<class T , bool SAFE = true>

duckdb::atomic_ptr< T, SAFE >::operator bool ( ) const

inline

                          { // NOLINT: allow implicit conversion to bool
        return ptr;
    }

operator*() [1/2]

template<class T , bool SAFE = true>

T & duckdb::atomic_ptr< T, SAFE >::operator* ( )

inline

                   {
        return *GetPointer();
    }

operator*() [2/2]

template<class T , bool SAFE = true>

const T & duckdb::atomic_ptr< T, SAFE >::operator* ( ) const

inline

                               {
        return *GetPointer();
    }

operator->() [1/2]

template<class T , bool SAFE = true>

T * duckdb::atomic_ptr< T, SAFE >::operator-> ( )

inline

                    {
        return GetPointer();
    }

operator->() [2/2]

template<class T , bool SAFE = true>

const T * duckdb::atomic_ptr< T, SAFE >::operator-> ( ) const

inline

                                {
        return GetPointer();
    }

get() [1/2]

template<class T , bool SAFE = true>

T * duckdb::atomic_ptr< T, SAFE >::get ( )

inline

             { // NOLINT: mimic std casing
        return GetPointer();
    }

get() [2/2]

template<class T , bool SAFE = true>

const T * duckdb::atomic_ptr< T, SAFE >::get ( ) const

inline

                         { // NOLINT: mimic std casing
        return GetPointer();
    }

get_mutable()

template<class T , bool SAFE = true>

T * duckdb::atomic_ptr< T, SAFE >::get_mutable ( ) const

inline

                           { // NOLINT: mimic std casing
        return GetPointer();
    }

set()

template<class T , bool SAFE = true>

void duckdb::atomic_ptr< T, SAFE >::set ( T &  ref )

inline

                     {
        ptr = &ref;
    }

reset()

template<class T , bool SAFE = true>

void duckdb::atomic_ptr< T, SAFE >::reset ( )

inline

                 {
        ptr = nullptr;
    }

operator==()

template<class T , bool SAFE = true>

bool duckdb::atomic_ptr< T, SAFE >::operator== ( const atomic_ptr< T > &  rhs ) const

inline

                                                    {
        return ptr.load() == rhs.ptr.load();
    }

operator!=()

template<class T , bool SAFE = true>

bool duckdb::atomic_ptr< T, SAFE >::operator!= ( const atomic_ptr< T > &  rhs ) const

inline

                                                    {
        return ptr.load() != rhs.ptr.load();
    }

---

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

• external/duckdb/duckdb.hpp