Slic3r::AnyPtr< T > Class Template Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/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}
    {}

References ptr.

Referenced by AnyPtr(), AnyPtr(), operator=(), operator=(), operator=(), operator=(), operator=(), and operator=().

Here is the caller graph for this function:

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))}
    {}

References ptr.

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))}
    {}

References ptr.

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))}
    {}

References ptr.

~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)} {}

References AnyPtr(), and ptr.

Here is the call graph for this function:

AnyPtr() [6/6]

template<class T>

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

delete

References AnyPtr().

Here is the call graph for this function:

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 ptr, and UPtr.

get() [1/2]

template<class T>

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

inline

{ return get_ptr(*this); }

References get_ptr().

Referenced by get_ptr().

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 get_ptr().

Here is the call graph for this function:

get_ptr()

template<class T>

template<class Self>

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 get(), RawPtr, ShPtr, UPtr, and WkPtr.

Referenced by get(), get(), operator*(), operator*(), operator->(), and 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 ptr, ShPtr, and WkPtr.

is_owned()

template<class T>

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

inlinenoexcept

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

References ptr, ShPtr, and 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 ptr, RawPtr, ShPtr, UPtr, and WkPtr.

operator*() [1/2]

template<class T>

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

inline

{ return *get_ptr(*this); }

References 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 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 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 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 AnyPtr(), and ptr.

Here is the call graph for this function:

operator=() [2/6]

template<class T>

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

delete

References AnyPtr().

Here is the call graph for this function:

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 AnyPtr(), and ptr.

Here is the call graph for this function:

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 AnyPtr(), and ptr.

Here is the call graph for this function:

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 AnyPtr(), and ptr.

Here is the call graph for this function:

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 AnyPtr(), and ptr.

Here is the call graph for this function:

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 AnyPtr(), AnyPtr(), AnyPtr(), AnyPtr(), AnyPtr(), convert_unique_to_shared(), get_shared_cpy(), is_owned(), operator bool(), operator=(), operator=(), operator=(), operator=(), and operator=().

---

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

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