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

Public Member Functions
	optional_ptr (T *ptr_p)
	optional_ptr (T &ref)
	optional_ptr (const unique_ptr< T > &ptr_p)
	optional_ptr (const shared_ptr< T > &ptr_p)
void	CheckValid () 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
bool	operator== (const optional_ptr< T > &rhs) const
bool	operator!= (const optional_ptr< T > &rhs) const

Private Attributes
T *	ptr

Constructor & Destructor Documentation

optional_ptr() [1/5]

template<class T , bool SAFE = true>

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

inlinenoexcept

                            : ptr(nullptr) {
    }

optional_ptr() [2/5]

template<class T , bool SAFE = true>

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

inline

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

optional_ptr() [3/5]

template<class T , bool SAFE = true>

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

inline

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

optional_ptr() [4/5]

template<class T , bool SAFE = true>

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

inline

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

optional_ptr() [5/5]

template<class T , bool SAFE = true>

duckdb::optional_ptr< T, SAFE >::optional_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::optional_ptr< T, SAFE >::CheckValid ( ) const

inline

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

operator bool()

template<class T , bool SAFE = true>

duckdb::optional_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::optional_ptr< T, SAFE >::operator* ( )

inline

                   {
        CheckValid();
        return *ptr;
    }

operator*() [2/2]

template<class T , bool SAFE = true>

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

inline

                               {
        CheckValid();
        return *ptr;
    }

operator->() [1/2]

template<class T , bool SAFE = true>

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

inline

                    {
        CheckValid();
        return ptr;
    }

operator->() [2/2]

template<class T , bool SAFE = true>

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

inline

                                {
        CheckValid();
        return ptr;
    }

get() [1/2]

template<class T , bool SAFE = true>

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

inline

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

get() [2/2]

template<class T , bool SAFE = true>

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

inline

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

get_mutable()

template<class T , bool SAFE = true>

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

inline

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

operator==()

template<class T , bool SAFE = true>

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

inline

                                                      {
        return ptr == rhs.ptr;
    }

operator!=()

template<class T , bool SAFE = true>

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

inline

                                                      {
        return ptr != rhs.ptr;
    }

---

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

• external/duckdb/duckdb.hpp