Slic3r::AnyPtr< T > Class Template Reference

#include <src/libslic3r/AnyPtr.hpp>

Inheritance diagram for Slic3r::AnyPtr< T >:

Public Member Functions
template<class TT = T, class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
	AnyPtr (TT *p=nullptr)
template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
	AnyPtr (std::unique_ptr< TT > p)
template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
	AnyPtr (std::shared_ptr< TT > p)
template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
	AnyPtr (std::weak_ptr< TT > p)
	~AnyPtr ()=default
	AnyPtr (AnyPtr &&other) noexcept
	AnyPtr (const AnyPtr &other)=delete
AnyPtr &	operator= (AnyPtr &&other) noexcept
AnyPtr &	operator= (const AnyPtr &other)=delete
template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
AnyPtr &	operator= (TT *p)
template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
AnyPtr &	operator= (std::unique_ptr< TT > p)
template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
AnyPtr &	operator= (std::shared_ptr< TT > p)
template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
AnyPtr &	operator= (std::weak_ptr< TT > p)
const T &	operator* () const
T &	operator* ()
T *	operator-> ()
const T *	operator-> () const
T *	get ()
const T *	get () const
	operator bool () const
std::shared_ptr< T >	get_shared_cpy () const
void	convert_unique_to_shared ()
bool	is_owned () const noexcept

Private Types
enum	{ RawPtr , UPtr , ShPtr , WkPtr }

Static Private Member Functions
template<class Self >
static T *	get_ptr (Self &&s)

Private Attributes
boost::variant< T *, std::unique_ptr< T >, std::shared_ptr< T >, std::weak_ptr< T > >	ptr

Detailed Description

template<class T>
class Slic3r::AnyPtr< T >

Member Enumeration Documentation

anonymous enum

template<class T >

anonymous enum

private

Enumerator
RawPtr
UPtr
ShPtr
WkPtr

{ RawPtr, UPtr, ShPtr, WkPtr };

Constructor & Destructor Documentation

AnyPtr() [1/6]

template<class T >

template<class TT = T, class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

Slic3r::AnyPtr< T >::AnyPtr ( TT *  p = nullptr )

inline

                            : ptr{p}
    {}

AnyPtr() [2/6]

template<class T >

template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

Slic3r::AnyPtr< T >::AnyPtr ( std::unique_ptr< TT >  p )

inline

                                : ptr{std::unique_ptr<T>(std::move(p))}
    {}

AnyPtr() [3/6]

template<class T >

template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

Slic3r::AnyPtr< T >::AnyPtr ( std::shared_ptr< TT >  p )

inline

                                : ptr{std::shared_ptr<T>(std::move(p))}
    {}

AnyPtr() [4/6]

template<class T >

template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

Slic3r::AnyPtr< T >::AnyPtr ( std::weak_ptr< TT >  p )

inline

                              : ptr{std::weak_ptr<T>(std::move(p))}
    {}

~AnyPtr()

template<class T >

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

default

AnyPtr() [5/6]

template<class T >

Slic3r::AnyPtr< T >::AnyPtr ( AnyPtr< T > &&  other )

inlinenoexcept

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

AnyPtr() [6/6]

template<class T >

Slic3r::AnyPtr< T >::AnyPtr ( const AnyPtr< T > &  other )

delete

Member Function Documentation

convert_unique_to_shared()

template<class T >

void Slic3r::AnyPtr< T >::convert_unique_to_shared ( )

inline

    {
        if (ptr.which() == UPtr)
            ptr = std::shared_ptr<T>{std::move(boost::get<std::unique_ptr<T>>(ptr))};
    }

References Slic3r::AnyPtr< T >::ptr, and Slic3r::AnyPtr< T >::UPtr.

get() [1/2]

template<class T >

T * Slic3r::AnyPtr< T >::get ( )

inline

{ return get_ptr(*this); }

References Slic3r::AnyPtr< T >::get_ptr().

Referenced by Slic3r::AnyPtr< T >::get_ptr(), Slic3r::GUI::MeshClipper::set_mesh(), Slic3r::GUI::MeshClipper::set_mesh(), Slic3r::GUI::MeshClipper::set_negative_mesh(), and Slic3r::GUI::MeshClipper::set_negative_mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

get() [2/2]

template<class T >

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

inline

{ return get_ptr(*this); }

References Slic3r::AnyPtr< T >::get_ptr().

Here is the call graph for this function:

get_ptr()

template<class T >

template<class Self >

static T * Slic3r::AnyPtr< T >::get_ptr ( Self &&  s )

inlinestaticprivate

    {
        switch (s.ptr.which()) {
        case RawPtr: return boost::get<T *>(s.ptr);
        case UPtr: return boost::get<std::unique_ptr<T>>(s.ptr).get();
        case ShPtr: return boost::get<std::shared_ptr<T>>(s.ptr).get();
        case WkPtr: {
            auto shptr = boost::get<std::weak_ptr<T>>(s.ptr).lock();
            return shptr.get();
        }
        }
 
        return nullptr;
    }

References Slic3r::AnyPtr< T >::get(), Slic3r::AnyPtr< T >::RawPtr, Slic3r::AnyPtr< T >::ShPtr, Slic3r::AnyPtr< T >::UPtr, and Slic3r::AnyPtr< T >::WkPtr.

Referenced by Slic3r::AnyPtr< T >::get(), Slic3r::AnyPtr< T >::get(), Slic3r::AnyPtr< T >::operator*(), Slic3r::AnyPtr< T >::operator*(), Slic3r::AnyPtr< T >::operator->(), and Slic3r::AnyPtr< T >::operator->().

Here is the call graph for this function:

Here is the caller graph for this function:

get_shared_cpy()

template<class T >

std::shared_ptr< T > Slic3r::AnyPtr< T >::get_shared_cpy ( ) const

inline

    {
        std::shared_ptr<T> ret;
 
        switch (ptr.which()) {
        case ShPtr: ret = boost::get<std::shared_ptr<T>>(ptr); break;
        case WkPtr: ret = boost::get<std::weak_ptr<T>>(ptr).lock(); break;
        default:
            ;
        }
 
        return ret;
    }

References Slic3r::AnyPtr< T >::ptr, Slic3r::AnyPtr< T >::ShPtr, and Slic3r::AnyPtr< T >::WkPtr.

is_owned()

template<class T >

bool Slic3r::AnyPtr< T >::is_owned ( ) const

inlinenoexcept

    {
        return ptr.which() == UPtr || ptr.which() == ShPtr;
    }

References Slic3r::AnyPtr< T >::ptr, Slic3r::AnyPtr< T >::ShPtr, and Slic3r::AnyPtr< T >::UPtr.

operator bool()

template<class T >

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

inline

    {
        switch (ptr.which()) {
        case RawPtr: return bool(boost::get<T *>(ptr));
        case UPtr: return bool(boost::get<std::unique_ptr<T>>(ptr));
        case ShPtr: return bool(boost::get<std::shared_ptr<T>>(ptr));
        case WkPtr: {
            auto shptr = boost::get<std::weak_ptr<T>>(ptr).lock();
            return bool(shptr);
        }
        }
 
        return false;
    }

References Slic3r::AnyPtr< T >::ptr, Slic3r::AnyPtr< T >::RawPtr, Slic3r::AnyPtr< T >::ShPtr, Slic3r::AnyPtr< T >::UPtr, and Slic3r::AnyPtr< T >::WkPtr.

operator*() [1/2]

template<class T >

T & Slic3r::AnyPtr< T >::operator* ( )

inline

{ return *get_ptr(*this); }

References Slic3r::AnyPtr< T >::get_ptr().

Here is the call graph for this function:

operator*() [2/2]

template<class T >

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

inline

{ return *get_ptr(*this); }

References Slic3r::AnyPtr< T >::get_ptr().

Here is the call graph for this function:

operator->() [1/2]

template<class T >

T * Slic3r::AnyPtr< T >::operator-> ( )

inline

{ return get_ptr(*this); }

References Slic3r::AnyPtr< T >::get_ptr().

Here is the call graph for this function:

operator->() [2/2]

template<class T >

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

inline

{ return get_ptr(*this); }

References Slic3r::AnyPtr< T >::get_ptr().

Here is the call graph for this function:

operator=() [1/6]

template<class T >

AnyPtr & Slic3r::AnyPtr< T >::operator= ( AnyPtr< T > &&  other )

inlinenoexcept

{ ptr = std::move(other.ptr); return *this; }

References Slic3r::AnyPtr< T >::ptr.

operator=() [2/6]

template<class T >

AnyPtr & Slic3r::AnyPtr< T >::operator= ( const AnyPtr< T > &  other )

delete

operator=() [3/6]

template<class T >

template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

AnyPtr & Slic3r::AnyPtr< T >::operator= ( std::shared_ptr< TT >  p )

inline

{ ptr = p; return *this; }

References Slic3r::AnyPtr< T >::ptr.

operator=() [4/6]

template<class T >

template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

AnyPtr & Slic3r::AnyPtr< T >::operator= ( std::unique_ptr< TT >  p )

inline

{ ptr = std::move(p); return *this; }

References Slic3r::AnyPtr< T >::ptr.

operator=() [5/6]

template<class T >

template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

AnyPtr & Slic3r::AnyPtr< T >::operator= ( std::weak_ptr< TT >  p )

inline

{ ptr = std::move(p); return *this; }

References Slic3r::AnyPtr< T >::ptr.

operator=() [6/6]

template<class T >

template<class TT , class = std::enable_if_t<std::is_convertible_v<TT*, T*>>>

AnyPtr & Slic3r::AnyPtr< T >::operator= ( TT *  p )

inline

{ ptr = p; return *this; }

References Slic3r::AnyPtr< T >::ptr.

Member Data Documentation

ptr

template<class T >

boost::variant<T*, std::unique_ptr<T>, std::shared_ptr<T>, std::weak_ptr<T> > Slic3r::AnyPtr< T >::ptr

private

Referenced by Slic3r::AnyPtr< T >::convert_unique_to_shared(), Slic3r::AnyPtr< T >::get_shared_cpy(), Slic3r::AnyPtr< T >::is_owned(), Slic3r::AnyPtr< T >::operator bool(), Slic3r::AnyPtr< T >::operator=(), Slic3r::AnyPtr< T >::operator=(), Slic3r::AnyPtr< T >::operator=(), Slic3r::AnyPtr< T >::operator=(), and Slic3r::AnyPtr< T >::operator=().

---

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

• src/libslic3r/AnyPtr.hpp