Slic3r::clonable_ptr< T > Class Template Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/clonable_ptr.hpp>

Inheritance diagram for Slic3r::clonable_ptr< T >:

Public Types
typedef T	element_type
	The type of the managed object, aliased as member type.

Public Member Functions
	clonable_ptr () noexcept
	Default constructor.
	clonable_ptr (T *p) noexcept
	Constructor with the provided pointer to manage.
	clonable_ptr (const clonable_ptr &rhs)
	Copy constructor, clones by calling the rhs.clone() method.
	clonable_ptr (clonable_ptr &&rhs) noexcept
	Move constructor, never throws.
clonable_ptr &	operator= (const clonable_ptr &rhs)
	Assignment operator.
clonable_ptr &	operator= (clonable_ptr &&rhs)
	Move operator, never throws.
	~clonable_ptr () noexcept
	the destructor releases its ownership and destroy the object
void	reset () noexcept
	this reset releases its ownership and destroy the object
void	reset (T *p) noexcept
	this reset release its ownership and re-acquire another one
void	swap (clonable_ptr &rhs) noexcept
	Swap method for the copy-and-swap idiom (copy constructor and swap method).
void	release () noexcept
	release the ownership of the px pointer without destroying the object!
	operator bool () const noexcept
T &	operator* () const noexcept
T *	operator-> () const noexcept
T *	get () const noexcept

Private Member Functions
void	destroy () noexcept
	release the ownership of the px pointer and destroy the object
void	release () const noexcept
	hack: const-cast release the ownership of the px pointer without destroying the object!

Private Attributes
T *	px
	Native pointer.

Detailed Description

template<class T>
class Slic3r::clonable_ptr< T >

Member Typedef Documentation

element_type

template<class T>

typedef T Slic3r::clonable_ptr< T >::element_type

The type of the managed object, aliased as member type.

Constructor & Destructor Documentation

clonable_ptr() [1/4]

template<class T>

Slic3r::clonable_ptr< T >::clonable_ptr ( )

inlinenoexcept

Default constructor.

                            :
        px(nullptr)
    {
    }

References px.

Referenced by clonable_ptr(), clonable_ptr(), operator=(), operator=(), and swap().

Here is the caller graph for this function:

clonable_ptr() [2/4]

template<class T>

Slic3r::clonable_ptr< T >::clonable_ptr ( T * p )

inlineexplicitnoexcept

Constructor with the provided pointer to manage.

                                         :
        px(p)
    {
    }

clonable_ptr() [3/4]

template<class T>

Slic3r::clonable_ptr< T >::clonable_ptr ( const clonable_ptr< T > & rhs )

inline

Copy constructor, clones by calling the rhs.clone() method.

                                          :
    px(rhs ? rhs.px->clone() : nullptr)
    {
    }

References clonable_ptr(), and px.

Here is the call graph for this function:

clonable_ptr() [4/4]

template<class T>

Slic3r::clonable_ptr< T >::clonable_ptr ( clonable_ptr< T > && rhs )

inlinenoexcept

Move constructor, never throws.

                                              :
        px(rhs.px)
    {
        rhs.px = nullptr;
    }

References clonable_ptr().

Here is the call graph for this function:

~clonable_ptr()

template<class T>

Slic3r::clonable_ptr< T >::~clonable_ptr ( )

inlinenoexcept

the destructor releases its ownership and destroy the object

    {
        destroy();
    }

References destroy().

Here is the call graph for this function:

Member Function Documentation

destroy()

template<class T>

void Slic3r::clonable_ptr< T >::destroy ( )

inlineprivatenoexcept

release the ownership of the px pointer and destroy the object

    {
        delete px;
        px = nullptr;
    }

References px.

Referenced by ~clonable_ptr(), reset(), and reset().

Here is the caller graph for this function:

get()

template<class T>

T * Slic3r::clonable_ptr< T >::get ( ) const

inlinenoexcept

    {
        // no assert, can return nullptr
        return px;
    }

References px.

Referenced by Slic3r::ConfigOptionDef::get_default_value().

Here is the caller graph for this function:

operator bool()

template<class T>

Slic3r::clonable_ptr< T >::operator bool ( ) const

inlinenoexcept

    {
        return (nullptr != px); // TODO nullptrptr
    }

References px.

operator*()

template<class T>

T & Slic3r::clonable_ptr< T >::operator* ( ) const

inlinenoexcept

    {
        assert(nullptr != px);
        return *px;
    }

References px.

operator->()

template<class T>

T * Slic3r::clonable_ptr< T >::operator-> ( ) const

inlinenoexcept

    {
        assert(nullptr != px);
        return px;
    }

References px.

operator=() [1/2]

template<class T>

clonable_ptr & Slic3r::clonable_ptr< T >::operator= ( clonable_ptr< T > && rhs )

inline

Move operator, never throws.

    {
    delete px;
        px = rhs.px;
        rhs.px = nullptr;
        return *this;
    }

References clonable_ptr(), and px.

Here is the call graph for this function:

operator=() [2/2]

template<class T>

clonable_ptr & Slic3r::clonable_ptr< T >::operator= ( const clonable_ptr< T > & rhs )

inline

Assignment operator.

    {
    delete px;
    px = rhs ? rhs.px->clone() : nullptr;
        return *this;
    }

References clonable_ptr(), and px.

Here is the call graph for this function:

release() [1/2]

template<class T>

void Slic3r::clonable_ptr< T >::release ( ) const

inlineprivatenoexcept

hack: const-cast release the ownership of the px pointer without destroying the object!

    {
        px = nullptr;
    }

References px.

release() [2/2]

template<class T>

void Slic3r::clonable_ptr< T >::release ( )

inlinenoexcept

release the ownership of the px pointer without destroying the object!

    {
        px = nullptr;
    }

References px.

reset() [1/2]

template<class T>

void Slic3r::clonable_ptr< T >::reset ( )

inlinenoexcept

this reset releases its ownership and destroy the object

    {
        destroy();
    }

References destroy().

Here is the call graph for this function:

reset() [2/2]

template<class T>

void Slic3r::clonable_ptr< T >::reset ( T * p )

inlinenoexcept

this reset release its ownership and re-acquire another one

    {
        assert((nullptr == p) || (px != p)); // auto-reset not allowed
        destroy();
        px = p;
    }

References destroy(), and px.

Here is the call graph for this function:

swap()

template<class T>

void Slic3r::clonable_ptr< T >::swap ( clonable_ptr< T > & rhs )

inlinenoexcept

Swap method for the copy-and-swap idiom (copy constructor and swap method).

    {
        T *tmp = px;
        px = rhs.px;
        rhs.px = tmp;
    }

References clonable_ptr(), and px.

Here is the call graph for this function:

Member Data Documentation

px

template<class T>

T* Slic3r::clonable_ptr< T >::px

private

Native pointer.

Referenced by clonable_ptr(), clonable_ptr(), destroy(), get(), operator bool(), operator*(), operator->(), operator=(), operator=(), release(), release(), reset(), and swap().

---

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

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/libslic3r/clonable_ptr.hpp