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

Public Types
using	original = std::weak_ptr< T >
using	element_type = typename original::element_type

Public Member Functions
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
	weak_ptr (shared_ptr< U, SAFE > const &ptr) noexcept
	weak_ptr (weak_ptr const &other) noexcept
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
	weak_ptr (weak_ptr< U > const &ptr) noexcept
	weak_ptr (weak_ptr &&ptr) noexcept
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
	weak_ptr (weak_ptr< U > &&ptr) noexcept
weak_ptr &	operator= (const weak_ptr &other)
template<class U , typename std::enable_if< compatible_with_t< U, T >::value, int >::type = 0>
weak_ptr &	operator= (const shared_ptr< U, SAFE > &ptr)
void	reset ()
long	use_count () const
bool	expired () const
shared_ptr< T, SAFE >	lock () const
template<typename U >
bool	operator== (const weak_ptr< U > &other) const noexcept
template<typename U >
bool	operator!= (const weak_ptr< U > &other) const noexcept
template<typename U >
bool	operator< (const weak_ptr< U > &other) const noexcept
template<typename U >
bool	operator<= (const weak_ptr< U > &other) const noexcept
template<typename U >
bool	operator> (const weak_ptr< U > &other) const noexcept
template<typename U >
bool	operator>= (const weak_ptr< U > &other) const noexcept

Private Attributes
original	internal

Friends
template<class U , bool SAFE_P>
class	shared_ptr

Constructor & Destructor Documentation

weak_ptr() [1/6]

template<typename T , bool SAFE>

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

inline

               : internal() {
    }

weak_ptr() [2/6]

template<typename T , bool SAFE>

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

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

inlinenoexcept

                                                      : internal(ptr.internal) {
    }

weak_ptr() [3/6]

template<typename T , bool SAFE>

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

inlinenoexcept

                                             : internal(other.internal) {
    }

weak_ptr() [4/6]

template<typename T , bool SAFE>

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

duckdb::weak_ptr< T, SAFE >::weak_ptr ( weak_ptr< U > const &  ptr )

inlinenoexcept

                                              : internal(ptr.internal) {
    }

weak_ptr() [5/6]

template<typename T , bool SAFE>

duckdb::weak_ptr< T, SAFE >::weak_ptr ( weak_ptr< T, SAFE > &&  ptr )

inlinenoexcept

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

weak_ptr() [6/6]

template<typename T , bool SAFE>

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

duckdb::weak_ptr< T, SAFE >::weak_ptr ( weak_ptr< U > &&  ptr )

inlinenoexcept

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

Member Function Documentation

operator=() [1/2]

template<typename T , bool SAFE>

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

inline

                                               {
        if (this == &other) {
            return *this;
        }
        internal = other.internal;
        return *this;
    }

operator=() [2/2]

template<typename T , bool SAFE>

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

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

inline

                                                        {
        internal = ptr.internal;
        return *this;
    }

reset()

template<typename T , bool SAFE>

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

inline

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

use_count()

template<typename T , bool SAFE>

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

inline

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

expired()

template<typename T , bool SAFE>

bool duckdb::weak_ptr< T, SAFE >::expired ( ) const

inline

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

lock()

template<typename T , bool SAFE>

shared_ptr< T, SAFE > duckdb::weak_ptr< T, SAFE >::lock ( ) const

inline

                                     { // NOLINT: invalid case style
        return shared_ptr<T, SAFE>(internal.lock());
    }

operator==()

template<typename T , bool SAFE>

template<typename U >

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

inlinenoexcept

                                                             {
        return internal == other.internal;
    }

operator!=()

template<typename T , bool SAFE>

template<typename U >

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

inlinenoexcept

                                                             {
        return internal != other.internal;
    }

operator<()

template<typename T , bool SAFE>

template<typename U >

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

inlinenoexcept

                                                            {
        return internal < other.internal;
    }

operator<=()

template<typename T , bool SAFE>

template<typename U >

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

inlinenoexcept

                                                             {
        return internal <= other.internal;
    }

operator>()

template<typename T , bool SAFE>

template<typename U >

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

inlinenoexcept

                                                            {
        return internal > other.internal;
    }

operator>=()

template<typename T , bool SAFE>

template<typename U >

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

inlinenoexcept

                                                             {
        return internal >= other.internal;
    }

---

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

• external/duckdb/duckdb.hpp