duckdb::optionally_owned_ptr< T > Class Template Reference

Collaboration diagram for duckdb::optionally_owned_ptr< T >:

Public Member Functions
	optionally_owned_ptr (T *ptr_p)
	optionally_owned_ptr (T &ref)
	optionally_owned_ptr (unique_ptr< T > &&owned_p)
	optionally_owned_ptr (shared_ptr< T > owned_p)
	optionally_owned_ptr (optionally_owned_ptr &&other) noexcept
	optionally_owned_ptr (const optionally_owned_ptr &other)=delete
	operator bool () const
T &	operator* ()
const T &	operator* () const
T *	operator-> ()
const T *	operator-> () const
T *	get ()
const T *	get () const
bool	is_owned () const
const unique_ptr< T > &	get_owned_unique () const
const shared_ptr< T > &	get_owned_shared () const
T *	get_mutable () const
optionally_owned_ptr< T > &	operator= (T &ref)
optionally_owned_ptr< T > &	operator= (T *ref)
bool	operator== (const optionally_owned_ptr< T > &rhs) const
bool	operator!= (const optionally_owned_ptr< T > &rhs) const

Private Attributes
unique_ptr< T >	owned
shared_ptr< T >	owned_shared
optional_ptr< T >	ptr

Constructor & Destructor Documentation

optionally_owned_ptr() [1/6]

template<class T >

duckdb::optionally_owned_ptr< T >::optionally_owned_ptr ( )

inline

                           {
    }

optionally_owned_ptr() [2/6]

template<class T >

duckdb::optionally_owned_ptr< T >::optionally_owned_ptr ( T *  ptr_p )

inline

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

optionally_owned_ptr() [3/6]

template<class T >

duckdb::optionally_owned_ptr< T >::optionally_owned_ptr ( T &  ref )

inline

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

optionally_owned_ptr() [4/6]

template<class T >

duckdb::optionally_owned_ptr< T >::optionally_owned_ptr ( unique_ptr< T > &&  owned_p )

inline

        : owned(std::move(owned_p)), ptr(owned) {
    }

optionally_owned_ptr() [5/6]

template<class T >

duckdb::optionally_owned_ptr< T >::optionally_owned_ptr ( shared_ptr< T >  owned_p )

inline

        : owned_shared(std::move(owned_p)), ptr(*owned_shared) {
    }

optionally_owned_ptr() [6/6]

template<class T >

duckdb::optionally_owned_ptr< T >::optionally_owned_ptr ( optionally_owned_ptr< T > &&  other )

inlinenoexcept

        : owned(std::move(other.owned)), owned_shared(std::move(other.owned_shared)), ptr(other.ptr) {
        other.ptr = nullptr;
    }

Member Function Documentation

operator bool()

template<class T >

duckdb::optionally_owned_ptr< T >::operator bool ( ) const

inline

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

operator*() [1/2]

template<class T >

T & duckdb::optionally_owned_ptr< T >::operator* ( )

inline

                   {
        return *ptr;
    }

operator*() [2/2]

template<class T >

const T & duckdb::optionally_owned_ptr< T >::operator* ( ) const

inline

                               {
        return *ptr;
    }

operator->() [1/2]

template<class T >

T * duckdb::optionally_owned_ptr< T >::operator-> ( )

inline

                    {
        return ptr.get();
    }

operator->() [2/2]

template<class T >

const T * duckdb::optionally_owned_ptr< T >::operator-> ( ) const

inline

                                {
        return ptr.get();
    }

get() [1/2]

template<class T >

T * duckdb::optionally_owned_ptr< T >::get ( )

inline

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

get() [2/2]

template<class T >

const T * duckdb::optionally_owned_ptr< T >::get ( ) const

inline

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

is_owned()

template<class T >

bool duckdb::optionally_owned_ptr< T >::is_owned ( ) const

inline

                          { // NOLINT: mimic std casing
        return owned != nullptr || owned_shared != nullptr;
    }

get_owned_unique()

template<class T >

const unique_ptr< T > & duckdb::optionally_owned_ptr< T >::get_owned_unique ( ) const

inline

                                                  {
        return owned;
    }

get_owned_shared()

template<class T >

const shared_ptr< T > & duckdb::optionally_owned_ptr< T >::get_owned_shared ( ) const

inline

                                                  {
        return owned_shared;
    }

get_mutable()

template<class T >

T * duckdb::optionally_owned_ptr< T >::get_mutable ( ) const

inline

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

operator=() [1/2]

template<class T >

optionally_owned_ptr< T > & duckdb::optionally_owned_ptr< T >::operator= ( T &  ref )

inline

                                               {
        owned = nullptr;
        owned_shared = nullptr;
        ptr = optional_ptr<T>(ref);
        return *this;
    }

operator=() [2/2]

template<class T >

optionally_owned_ptr< T > & duckdb::optionally_owned_ptr< T >::operator= ( T *  ref )

inline

                                               {
        owned = nullptr;
        owned_shared = nullptr;
        ptr = optional_ptr<T>(ref);
        return *this;
    }

operator==()

template<class T >

bool duckdb::optionally_owned_ptr< T >::operator== ( const optionally_owned_ptr< T > &  rhs ) const

inline

                                                              {
        if (owned != rhs.owned) {
            return false;
        }
        if (owned_shared != rhs.owned_shared) {
            return false;
        }
        return ptr == rhs.ptr;
    }

operator!=()

template<class T >

bool duckdb::optionally_owned_ptr< T >::operator!= ( const optionally_owned_ptr< T > &  rhs ) const

inline

                                                              {
        return !(*this == rhs);
    }

---

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

• external/duckdb/duckdb.hpp