pma::ScopedPtr< T, TDestroyer > Class Template Reference

Takes ownership over the given pointer and handles it's lifetime. More...

#include <ScopedPtr.h>

Inheritance diagram for pma::ScopedPtr< T, TDestroyer >:

Collaboration diagram for pma::ScopedPtr< T, TDestroyer >:

Classes
struct	inspect
struct	inspect< U[]>

Public Types
using	pointer = typename inspect< T >::pointer_type
using	element_type = typename inspect< T >::element_type
using	destroyer_type = TDestroyer

Public Member Functions
	ScopedPtr ()
	ScopedPtr (pointer ptr_)
	ScopedPtr (pointer ptr_, destroyer_type &&destroyer)
	~ScopedPtr ()
	ScopedPtr (std::nullptr_t)
ScopedPtr &	operator= (std::nullptr_t)
	ScopedPtr (const ScopedPtr &)=delete
ScopedPtr &	operator= (const ScopedPtr &)=delete
	ScopedPtr (ScopedPtr &&rhs) noexcept
ScopedPtr &	operator= (ScopedPtr &&rhs) noexcept
template<typename U , class UDestroyer >
	ScopedPtr (ScopedPtr< U, UDestroyer > &&rhs) noexcept
template<typename U , class UDestroyer >
ScopedPtr &	operator= (ScopedPtr< U, UDestroyer > &&rhs) noexcept
template<typename U = T, typename IA = typename inspect<U>::is_array>
std::enable_if< IA::value, element_type & >::type	operator[] (std::size_t index) const noexcept
template<typename U = T, typename IA = typename inspect<U>::is_array>
std::enable_if<!IA::value, element_type & >::type	operator* () const noexcept
pointer	operator-> () const noexcept
	operator bool () const noexcept
pointer	get () const noexcept
pointer	release () noexcept
void	reset (pointer rhs=pointer()) noexcept
void	swap (ScopedPtr &rhs) noexcept

Private Attributes
pointer	ptr

Friends
template<typename U , class UDestroyer >
class	ScopedPtr

Detailed Description

template<class T, class TDestroyer = typename DefaultInstanceDestroyer<T>::type>
class pma::ScopedPtr< T, TDestroyer >

Takes ownership over the given pointer and handles it's lifetime.

Note

As ScopedPtr inherits the specified destroyer type, stateless lifetime managers are zero-cost, but it's also possible to use stateful lifetime managers (such as lambdas with captures and what-not). For stateful lifetime managers, a dedicated constructor exists that receives the destroyer instance and initializes the inherited destroyer type with it.

See also

makeScoped

New

Delete

FactoryCreate

FactoryDestroy

DefaultInstanceCreator

DefaultInstanceDestroyer

Member Typedef Documentation

destroyer_type

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

using pma::ScopedPtr< T, TDestroyer >::destroyer_type = TDestroyer

element_type

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

using pma::ScopedPtr< T, TDestroyer >::element_type = typename inspect<T>::element_type

pointer

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

using pma::ScopedPtr< T, TDestroyer >::pointer = typename inspect<T>::pointer_type

Constructor & Destructor Documentation

ScopedPtr() [1/7]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::ScopedPtr ( )

inline

                    : ptr{nullptr} {
        }

ScopedPtr() [2/7]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::ScopedPtr ( pointer  ptr_ )

inlineexplicit

                                         : ptr{ptr_} {
        }

ScopedPtr() [3/7]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::ScopedPtr ( pointer  ptr_, destroyer_type &&  destroyer  )

inline

                                                            : destroyer_type{std::move(destroyer)}, ptr{ptr_} {
        }

~ScopedPtr()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::~ScopedPtr ( )

inline

                     {
            if (ptr) {
                destroyer_type::operator()(ptr);
                ptr = pointer{};
            }
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

ScopedPtr() [4/7]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::ScopedPtr ( std::nullptr_t  )

inline

                                : ptr{nullptr} {
        }

ScopedPtr() [5/7]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::ScopedPtr ( const ScopedPtr< T, TDestroyer > &  )

delete

ScopedPtr() [6/7]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::ScopedPtr ( ScopedPtr< T, TDestroyer > &&  rhs )

inlinenoexcept

                                            : ptr{nullptr} {
            rhs.swap(*this);
        }

ScopedPtr() [7/7]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

template<typename U , class UDestroyer >

pma::ScopedPtr< T, TDestroyer >::ScopedPtr ( ScopedPtr< U, UDestroyer > &&  rhs )

inlinenoexcept

                                                           : ptr{nullptr} {
            ScopedPtr<T, destroyer_type> tmp{rhs.release(), static_cast<UDestroyer &&>(rhs)};
            tmp.swap(*this);
        }

Member Function Documentation

get()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pointer pma::ScopedPtr< T, TDestroyer >::get ( ) const

inlinenoexcept

                                     {
            return ptr;
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

operator bool()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pma::ScopedPtr< T, TDestroyer >::operator bool ( ) const

inlinenoexcept

                                       {
            return ptr != nullptr;
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

operator*()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

template<typename U = T, typename IA = typename inspect<U>::is_array>

std::enable_if<!IA::value, element_type & >::type pma::ScopedPtr< T, TDestroyer >::operator* ( ) const

inlinenoexcept

                                                                                      {
            return *ptr;
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

operator->()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pointer pma::ScopedPtr< T, TDestroyer >::operator-> ( ) const

inlinenoexcept

                                            {
            return ptr;
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

operator=() [1/4]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

ScopedPtr & pma::ScopedPtr< T, TDestroyer >::operator= ( const ScopedPtr< T, TDestroyer > &  )

delete

operator=() [2/4]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

ScopedPtr & pma::ScopedPtr< T, TDestroyer >::operator= ( ScopedPtr< T, TDestroyer > &&  rhs )

inlinenoexcept

                                                       {
            rhs.swap(*this);
            return *this;
        }

References pma::ScopedPtr< T, TDestroyer >::swap().

operator=() [3/4]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

template<typename U , class UDestroyer >

ScopedPtr & pma::ScopedPtr< T, TDestroyer >::operator= ( ScopedPtr< U, UDestroyer > &&  rhs )

inlinenoexcept

                                                                      {
            ScopedPtr<T, destroyer_type> tmp{rhs.release(), static_cast<UDestroyer &&>(rhs)};
            tmp.swap(*this);
            return *this;
        }

References pma::ScopedPtr< T, TDestroyer >::release().

operator=() [4/4]

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

ScopedPtr & pma::ScopedPtr< T, TDestroyer >::operator= ( std::nullptr_t  )

inline

                                           {
            reset();
            return *this;
        }

References pma::ScopedPtr< T, TDestroyer >::reset().

operator[]()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

template<typename U = T, typename IA = typename inspect<U>::is_array>

std::enable_if< IA::value, element_type & >::type pma::ScopedPtr< T, TDestroyer >::operator[] ( std::size_t  index ) const

inlinenoexcept

                                                                                                     {
            return ptr[index];
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

release()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pointer pma::ScopedPtr< T, TDestroyer >::release ( )

inlinenoexcept

                                   {
            pointer result = nullptr;
            std::swap(result, ptr);
            return result;
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

Referenced by pma::ScopedPtr< T, TDestroyer >::operator=(), and pma::ScopedPtr< T, TDestroyer >::reset().

reset()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

void pma::ScopedPtr< T, TDestroyer >::reset ( pointer  rhs = pointer() )

inlinenoexcept

                                                     {
            pointer old = release();
            ptr = rhs;
            if (old) {
                destroyer_type::operator()(old);
            }
        }

References pma::ScopedPtr< T, TDestroyer >::ptr, and pma::ScopedPtr< T, TDestroyer >::release().

Referenced by pma::ScopedPtr< T, TDestroyer >::operator=().

swap()

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

void pma::ScopedPtr< T, TDestroyer >::swap ( ScopedPtr< T, TDestroyer > &  rhs )

inlinenoexcept

                                           {
            std::swap(static_cast<destroyer_type&>(*this), static_cast<destroyer_type&>(rhs));
            std::swap(ptr, rhs.ptr);
        }

References pma::ScopedPtr< T, TDestroyer >::ptr.

Referenced by pma::ScopedPtr< T, TDestroyer >::operator=().

Friends And Related Function Documentation

ScopedPtr

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

template<typename U , class UDestroyer >

friend class ScopedPtr

friend

Member Data Documentation

ptr

template<class T , class TDestroyer = typename DefaultInstanceDestroyer<T>::type>

pointer pma::ScopedPtr< T, TDestroyer >::ptr

private

Referenced by pma::ScopedPtr< T, TDestroyer >::get(), pma::ScopedPtr< T, TDestroyer >::operator bool(), pma::ScopedPtr< T, TDestroyer >::operator*(), pma::ScopedPtr< T, TDestroyer >::operator->(), pma::ScopedPtr< T, TDestroyer >::operator[](), pma::ScopedPtr< T, TDestroyer >::release(), pma::ScopedPtr< T, TDestroyer >::reset(), pma::ScopedPtr< T, TDestroyer >::swap(), and pma::ScopedPtr< T, TDestroyer >::~ScopedPtr().

---

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

• ScopedPtr.h