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

Public Types
using	original = std::shared_ptr< T >
using	element_type = typename original::element_type
using	weak_type = weak_ptr< T, SAFE >

Public Member Functions
	shared_ptr (std::nullptr_t)
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
	shared_ptr (U *ptr)
template<typename DELETER >
	shared_ptr (T *ptr, DELETER deleter)
template<class U >
	shared_ptr (const shared_ptr< U > &ref, T *ptr) noexcept
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
	shared_ptr (const shared_ptr< U > &ref) noexcept
	shared_ptr (const shared_ptr &other)
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
	shared_ptr (shared_ptr< U > &&ref) noexcept
	shared_ptr (shared_ptr< T, SAFE > &&other) noexcept
	shared_ptr (std::shared_ptr< T > other)
template<class U >
	shared_ptr (weak_ptr< U > other)
template<class U , class DELETER , bool SAFE_P, typename std::enable_if< compatible_with_t< U, T >::value &&std::is_convertible< typename unique_ptr< U, DELETER >::pointer, T * >::value, int >::type = 0>
	shared_ptr (unique_ptr< U, DELETER, SAFE_P > &&other)
shared_ptr< T, SAFE > &	operator= (const shared_ptr< T, SAFE > &other) noexcept
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
shared_ptr< T > &	operator= (const shared_ptr< U > &other)
shared_ptr< T, SAFE > &	operator= (shared_ptr &&other) noexcept
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
shared_ptr< T, SAFE > &	operator= (shared_ptr< U > &&other)
template<class U , class DELETER , bool SAFE_P, typename std::enable_if< compatible_with_t< U, T >::value &&std::is_convertible< typename unique_ptr< U, DELETER >::pointer, T * >::value, int >::type = 0>
shared_ptr< T, SAFE > &	operator= (unique_ptr< U, DELETER, SAFE_P > &&ref)
void	reset ()
template<typename U >
void	reset (U *ptr)
template<typename U , typename DELETER >
void	reset (U *ptr, DELETER deleter)
void	swap (shared_ptr &r) noexcept
T *	get () const
long	use_count () const
	operator bool () const noexcept
std::add_lvalue_reference< T >::type	operator* () const
T *	operator-> () const
template<typename U >
bool	operator== (const shared_ptr< U > &other) const noexcept
template<typename U >
bool	operator!= (const shared_ptr< U > &other) const noexcept
bool	operator== (std::nullptr_t) const noexcept
bool	operator!= (std::nullptr_t) const noexcept
template<typename U >
bool	operator< (const shared_ptr< U > &other) const noexcept
template<typename U >
bool	operator<= (const shared_ptr< U > &other) const noexcept
template<typename U >
bool	operator> (const shared_ptr< U > &other) const noexcept
template<typename U >
bool	operator>= (const shared_ptr< U > &other) const noexcept
shared_ptr< T, SAFE >	atomic_load () const
shared_ptr< T, SAFE >	atomic_load (std::memory_order order) const
void	atomic_store (const shared_ptr< T, SAFE > &new_ptr)

Private Member Functions
template<class U , class V , typename std::enable_if< std::is_convertible< V *, const enable_shared_from_this< U > * >::value, int >::type = 0>
void	__enable_weak_this (const enable_shared_from_this< U > *object, V *ptr) noexcept
void	__enable_weak_this (...) noexcept

Static Private Member Functions
static void	AssertNotNull (const bool null)

Private Attributes
original	internal

Friends
template<class U , bool SAFE_P>
class	weak_ptr
template<typename U , typename S >
shared_ptr< S >	shared_ptr_cast (shared_ptr< U > src)

Constructor & Destructor Documentation

shared_ptr() [1/12]

template<typename T , bool SAFE = true>

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

inline

                 : internal() {
    }

shared_ptr() [2/12]

template<typename T , bool SAFE = true>

duckdb::shared_ptr< T, SAFE >::shared_ptr ( std::nullptr_t  )

inline

                             : internal(nullptr) { // NOLINT: not marked as explicit
    }

shared_ptr() [3/12]

template<typename T , bool SAFE = true>

template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>

duckdb::shared_ptr< T, SAFE >::shared_ptr ( U *  ptr )

inlineexplicit

                                : internal(ptr) {
        __enable_weak_this(internal.get(), internal.get());
    }

shared_ptr() [4/12]

template<typename T , bool SAFE = true>

template<typename DELETER >

duckdb::shared_ptr< T, SAFE >::shared_ptr ( T *  ptr, DELETER  deleter  )

inline

                                        : internal(ptr, deleter) {
        __enable_weak_this(internal.get(), internal.get());
    }

shared_ptr() [5/12]

template<typename T , bool SAFE = true>

template<class U >

duckdb::shared_ptr< T, SAFE >::shared_ptr ( const shared_ptr< U > &  ref, T *  ptr  )

inlinenoexcept

                                                          : internal(ref.internal, ptr) {
    }

shared_ptr() [6/12]

template<typename T , bool SAFE = true>

template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>

duckdb::shared_ptr< T, SAFE >::shared_ptr ( const shared_ptr< U > &  ref )

inlinenoexcept

                                                  : internal(ref.internal) { // NOLINT: not marked as explicit
    }

shared_ptr() [7/12]

template<typename T , bool SAFE = true>

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

inline

                                        : internal(other.internal) { // NOLINT: not marked as explicit
    }

shared_ptr() [8/12]

template<typename T , bool SAFE = true>

template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>

duckdb::shared_ptr< T, SAFE >::shared_ptr ( shared_ptr< U > &&  ref )

inlinenoexcept

        : internal(std::move(ref.internal)) {
    }

shared_ptr() [9/12]

template<typename T , bool SAFE = true>

duckdb::shared_ptr< T, SAFE >::shared_ptr ( shared_ptr< T, SAFE > &&  other )

inlinenoexcept

        : internal(std::move(other.internal)) {
    }

shared_ptr() [10/12]

template<typename T , bool SAFE = true>

duckdb::shared_ptr< T, SAFE >::shared_ptr ( std::shared_ptr< T >  other )

inlineexplicit

                                                : internal(other) {
        // FIXME: should we __enable_weak_this here?
        // *our* enable_shared_from_this hasn't initialized yet, so I think so?
        __enable_weak_this(internal.get(), internal.get());
    }

shared_ptr() [11/12]

template<typename T , bool SAFE = true>

template<class U >

duckdb::shared_ptr< T, SAFE >::shared_ptr ( weak_ptr< U >  other )

inlineexplicit

                                           : internal(other.internal) {
    }

shared_ptr() [12/12]

template<typename T , bool SAFE = true>

template<class U , class DELETER , bool SAFE_P, typename std::enable_if< compatible_with_t< U, T >::value &&std::is_convertible< typename unique_ptr< U, DELETER >::pointer, T * >::value, int >::type = 0>

duckdb::shared_ptr< T, SAFE >::shared_ptr ( unique_ptr< U, DELETER, SAFE_P > &&  other )

inline

        : internal(std::move(other)) {
        __enable_weak_this(internal.get(), internal.get());
    }

Member Function Documentation

AssertNotNull()

template<typename T , bool SAFE = true>

static void duckdb::shared_ptr< T, SAFE >::AssertNotNull ( const bool  null )

inlinestaticprivate

                                                      {
#if defined(DUCKDB_DEBUG_NO_SAFETY) || defined(DUCKDB_CLANG_TIDY)
        return;
#else
        if (DUCKDB_UNLIKELY(null)) {
            throw duckdb::InternalException("Attempted to dereference shared_ptr that is NULL!");
        }
#endif
    }

operator=() [1/5]

template<typename T , bool SAFE = true>

shared_ptr< T, SAFE > & duckdb::shared_ptr< T, SAFE >::operator= ( const shared_ptr< T, SAFE > &  other )

inlinenoexcept

                                                                              {
        if (this == &other) {
            return *this;
        }
        // Create a new shared_ptr using the copy constructor, then swap out the ownership to *this
        shared_ptr(other).swap(*this);
        return *this;
    }

operator=() [2/5]

template<typename T , bool SAFE = true>

template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>

shared_ptr< T > & duckdb::shared_ptr< T, SAFE >::operator= ( const shared_ptr< U > &  other )

inline

                                                         {
        shared_ptr(other).swap(*this);
        return *this;
    }

operator=() [3/5]

template<typename T , bool SAFE = true>

shared_ptr< T, SAFE > & duckdb::shared_ptr< T, SAFE >::operator= ( shared_ptr< T, SAFE > &&  other )

inlinenoexcept

                                                                {
        // Create a new shared_ptr using the move constructor, then swap out the ownership to *this
        shared_ptr(std::move(other)).swap(*this);
        return *this;
    }

operator=() [4/5]

template<typename T , bool SAFE = true>

template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>

shared_ptr< T, SAFE > & duckdb::shared_ptr< T, SAFE >::operator= ( shared_ptr< U > &&  other )

inline

                                                          {
        shared_ptr(std::move(other)).swap(*this);
        return *this;
    }

operator=() [5/5]

template<typename T , bool SAFE = true>

template<class U , class DELETER , bool SAFE_P, typename std::enable_if< compatible_with_t< U, T >::value &&std::is_convertible< typename unique_ptr< U, DELETER >::pointer, T * >::value, int >::type = 0>

shared_ptr< T, SAFE > & duckdb::shared_ptr< T, SAFE >::operator= ( unique_ptr< U, DELETER, SAFE_P > &&  ref )

inline

                                                                         {
        shared_ptr(std::move(ref)).swap(*this);
        return *this;
    }

reset() [1/3]

template<typename T , bool SAFE = true>

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

inline

            { // NOLINT: invalid case style
        internal.reset();
    }

reset() [2/3]

template<typename T , bool SAFE = true>

template<typename U >

void duckdb::shared_ptr< T, SAFE >::reset ( U *  ptr )

inline

                  { // NOLINT: invalid case style
        internal.reset(ptr);
    }

reset() [3/3]

template<typename T , bool SAFE = true>

template<typename U , typename DELETER >

void duckdb::shared_ptr< T, SAFE >::reset ( U *  ptr, DELETER  deleter  )

inline

                                   { // NOLINT: invalid case style
        internal.reset(ptr, deleter);
    }

swap()

template<typename T , bool SAFE = true>

void duckdb::shared_ptr< T, SAFE >::swap ( shared_ptr< T, SAFE > &  r )

inlinenoexcept

                                      { // NOLINT: invalid case style
        internal.swap(r.internal);
    }

get()

template<typename T , bool SAFE = true>

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

inline

                   { // NOLINT: invalid case style
        return internal.get();
    }

use_count()

template<typename T , bool SAFE = true>

long duckdb::shared_ptr< T, SAFE >::use_count ( ) const

inline

                           { // NOLINT: invalid case style
        return internal.use_count();
    }

operator bool()

template<typename T , bool SAFE = true>

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

inlineexplicitnoexcept

                                            {
        return internal.operator bool();
    }

operator*()

template<typename T , bool SAFE = true>

std::add_lvalue_reference< T >::type duckdb::shared_ptr< T, SAFE >::operator* ( ) const

inline

                                                              {
        if (MemorySafety<SAFE>::ENABLED) {
            const auto ptr = internal.get();
            AssertNotNull(!ptr);
            return *ptr;
        } else {
            return *internal;
        }
    }

operator->()

template<typename T , bool SAFE = true>

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

inline

                          {
        if (MemorySafety<SAFE>::ENABLED) {
            const auto ptr = internal.get();
            AssertNotNull(!ptr);
            return ptr;
        } else {
            return internal.operator->();
        }
    }

operator==() [1/2]

template<typename T , bool SAFE = true>

template<typename U >

bool duckdb::shared_ptr< T, SAFE >::operator== ( const shared_ptr< U > &  other ) const

inlinenoexcept

                                                               {
        return internal == other.internal;
    }

operator!=() [1/2]

template<typename T , bool SAFE = true>

template<typename U >

bool duckdb::shared_ptr< T, SAFE >::operator!= ( const shared_ptr< U > &  other ) const

inlinenoexcept

                                                               {
        return internal != other.internal;
    }

operator==() [2/2]

template<typename T , bool SAFE = true>

bool duckdb::shared_ptr< T, SAFE >::operator== ( std::nullptr_t  ) const

inlinenoexcept

                                                 {
        return internal == nullptr;
    }

operator!=() [2/2]

template<typename T , bool SAFE = true>

bool duckdb::shared_ptr< T, SAFE >::operator!= ( std::nullptr_t  ) const

inlinenoexcept

                                                 {
        return internal != nullptr;
    }

operator<()

template<typename T , bool SAFE = true>

template<typename U >

bool duckdb::shared_ptr< T, SAFE >::operator< ( const shared_ptr< U > &  other ) const

inlinenoexcept

                                                              {
        return internal < other.internal;
    }

operator<=()

template<typename T , bool SAFE = true>

template<typename U >

bool duckdb::shared_ptr< T, SAFE >::operator<= ( const shared_ptr< U > &  other ) const

inlinenoexcept

                                                               {
        return internal <= other.internal;
    }

operator>()

template<typename T , bool SAFE = true>

template<typename U >

bool duckdb::shared_ptr< T, SAFE >::operator> ( const shared_ptr< U > &  other ) const

inlinenoexcept

                                                              {
        return internal > other.internal;
    }

operator>=()

template<typename T , bool SAFE = true>

template<typename U >

bool duckdb::shared_ptr< T, SAFE >::operator>= ( const shared_ptr< U > &  other ) const

inlinenoexcept

                                                               {
        return internal >= other.internal;
    }

atomic_load() [1/2]

template<typename T , bool SAFE = true>

shared_ptr< T, SAFE > duckdb::shared_ptr< T, SAFE >::atomic_load ( ) const

inline

                                            {
        return shared_ptr<T, SAFE>(std::atomic_load(&internal));
    }

atomic_load() [2/2]

template<typename T , bool SAFE = true>

shared_ptr< T, SAFE > duckdb::shared_ptr< T, SAFE >::atomic_load ( std::memory_order  order ) const

inline

                                                                 {
        return shared_ptr<T, SAFE>(std::atomic_load_explicit(&internal, order));
    }

atomic_store()

template<typename T , bool SAFE = true>

void duckdb::shared_ptr< T, SAFE >::atomic_store ( const shared_ptr< T, SAFE > &  new_ptr )

inline

                                                          {
        std::atomic_store(&internal, new_ptr.internal);
    }

__enable_weak_this() [1/2]

template<typename T , bool SAFE = true>

template<class U , class V , typename std::enable_if< std::is_convertible< V *, const enable_shared_from_this< U > * >::value, int >::type = 0>

void duckdb::shared_ptr< T, SAFE >::__enable_weak_this ( const enable_shared_from_this< U > *  object, V *  ptr  )

inlineprivatenoexcept

                                             {
        typedef typename std::remove_cv<U>::type non_const_u_t;
        if (object && object->__weak_this_.expired()) {
            // __weak_this__ is the mutable variable returned by 'shared_from_this'
            // it is initialized here
            auto non_const = const_cast<non_const_u_t *>(static_cast<const U *>(ptr)); // NOLINT: const cast
            object->__weak_this_ = shared_ptr<non_const_u_t>(*this, non_const);
        }
    }

__enable_weak_this() [2/2]

template<typename T , bool SAFE = true>

void duckdb::shared_ptr< T, SAFE >::__enable_weak_this (   ... )

inlineprivatenoexcept

                                          { // NOLINT: invalid case style
    }

---

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

• external/duckdb/duckdb.hpp