inet::IntrusivePtr< T > Class Template Reference

A smart pointer that uses intrusive reference counting. More...

#include <IntrusivePtr.h>

Public Member Functions
constexpr INET_ALWAYS_INLINE	IntrusivePtr () noexcept
constexpr INET_ALWAYS_INLINE	IntrusivePtr (std::nullptr_t)
INET_ALWAYS_INLINE	IntrusivePtr (T *p)
template<class U >
INET_ALWAYS_INLINE	IntrusivePtr (IntrusivePtr< U > const &ptr)
INET_ALWAYS_INLINE	IntrusivePtr (IntrusivePtr const &ptr)
INET_ALWAYS_INLINE	~IntrusivePtr ()
template<class U >
INET_ALWAYS_INLINE IntrusivePtr &	operator= (IntrusivePtr< U > const &ptr)
INET_ALWAYS_INLINE	IntrusivePtr (IntrusivePtr &&ptr) noexcept
INET_ALWAYS_INLINE IntrusivePtr &	operator= (IntrusivePtr &&ptr) noexcept
template<class U >
INET_ALWAYS_INLINE	IntrusivePtr (IntrusivePtr< U > &&ptr)
template<class U >
INET_ALWAYS_INLINE IntrusivePtr &	operator= (IntrusivePtr< U > &&ptr) noexcept
INET_ALWAYS_INLINE IntrusivePtr &	operator= (IntrusivePtr const &ptr)
INET_ALWAYS_INLINE IntrusivePtr &	operator= (T *ptr)
INET_ALWAYS_INLINE void	reset ()
INET_ALWAYS_INLINE void	reset (T *ptr)
INET_ALWAYS_INLINE void	reset (T *ptr, bool add_ref)
INET_ALWAYS_INLINE T *	get () const noexcept
INET_ALWAYS_INLINE T *	detach () noexcept
INET_ALWAYS_INLINE T &	operator* () const noexcept
INET_ALWAYS_INLINE T *	operator-> () const noexcept
INET_ALWAYS_INLINE	operator bool () const noexcept
INET_ALWAYS_INLINE void	swap (IntrusivePtr &ptr) noexcept
INET_ALWAYS_INLINE unsigned int	use_count () const noexcept

Private Attributes
T *	p

Friends
template<class U >
class	IntrusivePtr

Detailed Description

template<class T>
class inet::IntrusivePtr< T >

A smart pointer that uses intrusive reference counting.

Relies on unqualified calls to void intrusivePtrCounterIncrement(T *p); void intrusivePtrCounterDecrement(T *p); The object is responsible for destroying itself.

Constructor & Destructor Documentation

IntrusivePtr() [1/7]

template<class T >

constexpr INET_ALWAYS_INLINE inet::IntrusivePtr< T >::IntrusivePtr ( )

inlineconstexprnoexcept

: p(nullptr) {}

IntrusivePtr() [2/7]

template<class T >

constexpr INET_ALWAYS_INLINE inet::IntrusivePtr< T >::IntrusivePtr ( std::nullptr_t  )

inlineconstexpr

: p(nullptr) {}

IntrusivePtr() [3/7]

template<class T >

INET_ALWAYS_INLINE inet::IntrusivePtr< T >::IntrusivePtr ( T *  p )

inlineexplicit

                                                   : p(p) {
        if (p != 0) intrusivePtrCounterIncrement(p);
    }

IntrusivePtr() [4/7]

template<class T >

template<class U >

INET_ALWAYS_INLINE inet::IntrusivePtr< T >::IntrusivePtr ( IntrusivePtr< U > const &  ptr )

inline

                                                                : p(ptr.get()) {
        if (p != 0) intrusivePtrCounterIncrement(p);
    }

IntrusivePtr() [5/7]

template<class T >

INET_ALWAYS_INLINE inet::IntrusivePtr< T >::IntrusivePtr ( IntrusivePtr< T > const &  ptr )

inline

                                                             : p(ptr.p) {
        if (p != 0) intrusivePtrCounterIncrement(p);
    }

~IntrusivePtr()

template<class T >

INET_ALWAYS_INLINE inet::IntrusivePtr< T >::~IntrusivePtr ( )

inline

                                       {
        if (p != 0) intrusivePtrCounterDecrement(p);
    }

IntrusivePtr() [6/7]

template<class T >

INET_ALWAYS_INLINE inet::IntrusivePtr< T >::IntrusivePtr ( IntrusivePtr< T > &&  ptr )

inlinenoexcept

                                                                 : p(ptr.p) {
        ptr.p = 0;
    }

IntrusivePtr() [7/7]

template<class T >

template<class U >

INET_ALWAYS_INLINE inet::IntrusivePtr< T >::IntrusivePtr ( IntrusivePtr< U > &&  ptr )

inline

                                                           : p(ptr.p) {
        ptr.p = 0;
    }

Member Function Documentation

detach()

template<class T >

INET_ALWAYS_INLINE T* inet::IntrusivePtr< T >::detach ( )

inlinenoexcept

                                            {
        T *ret = p;
        p = 0;
        return ret;
    }

get()

template<class T >

INET_ALWAYS_INLINE T* inet::IntrusivePtr< T >::get ( ) const

inlinenoexcept

{ return p; }

Referenced by inet::const_pointer_cast(), inet::dynamic_pointer_cast(), inet::operator<<(), and inet::static_pointer_cast().

operator bool()

template<class T >

INET_ALWAYS_INLINE inet::IntrusivePtr< T >::operator bool ( ) const

inlineexplicitnoexcept

{ return p != 0; }

operator*()

template<class T >

INET_ALWAYS_INLINE T& inet::IntrusivePtr< T >::operator* ( ) const

inlinenoexcept

{ return *p; }

operator->()

template<class T >

INET_ALWAYS_INLINE T* inet::IntrusivePtr< T >::operator-> ( ) const

inlinenoexcept

{ return p; }

operator=() [1/5]

template<class T >

INET_ALWAYS_INLINE IntrusivePtr& inet::IntrusivePtr< T >::operator= ( IntrusivePtr< T > &&  ptr )

inlinenoexcept

                                                                            {
        IntrusivePtr(static_cast<IntrusivePtr &&>(ptr)).swap(*this);
        return *this;
    }

operator=() [2/5]

template<class T >

INET_ALWAYS_INLINE IntrusivePtr& inet::IntrusivePtr< T >::operator= ( IntrusivePtr< T > const &  ptr )

inline

                                                                        {
        IntrusivePtr(ptr).swap(*this);
        return *this;
    }

operator=() [3/5]

template<class T >

template<class U >

INET_ALWAYS_INLINE IntrusivePtr& inet::IntrusivePtr< T >::operator= ( IntrusivePtr< U > &&  ptr )

inlinenoexcept

                                                                               {
        IntrusivePtr(static_cast<IntrusivePtr<U> &&>(ptr)).swap(*this);
        return *this;
    }

operator=() [4/5]

template<class T >

template<class U >

INET_ALWAYS_INLINE IntrusivePtr& inet::IntrusivePtr< T >::operator= ( IntrusivePtr< U > const &  ptr )

inline

                                                                           {
        IntrusivePtr(ptr).swap(*this);
        return *this;
    }

operator=() [5/5]

template<class T >

INET_ALWAYS_INLINE IntrusivePtr& inet::IntrusivePtr< T >::operator= ( T *  ptr )

inline

                                                       {
        IntrusivePtr(ptr).swap(*this);
        return *this;
    }

reset() [1/3]

template<class T >

INET_ALWAYS_INLINE void inet::IntrusivePtr< T >::reset ( )

inline

                                    {
        IntrusivePtr().swap(*this);
    }

reset() [2/3]

template<class T >

INET_ALWAYS_INLINE void inet::IntrusivePtr< T >::reset ( T *  ptr )

inline

                                          {
        IntrusivePtr(ptr).swap(*this);
    }

reset() [3/3]

template<class T >

INET_ALWAYS_INLINE void inet::IntrusivePtr< T >::reset ( T *  ptr, bool  add_ref  )

inline

                                                        {
        IntrusivePtr(ptr, add_ref).swap(*this);
    }

swap()

template<class T >

INET_ALWAYS_INLINE void inet::IntrusivePtr< T >::swap ( IntrusivePtr< T > &  ptr )

inlinenoexcept

                                                             {
        T *tmp = p;
        p = ptr.p;
        ptr.p = tmp;
    }

use_count()

template<class T >

INET_ALWAYS_INLINE unsigned int inet::IntrusivePtr< T >::use_count ( ) const

inlinenoexcept

{ return p->use_count(); }

Friends And Related Function Documentation

IntrusivePtr

template<class T >

template<class U >

friend class IntrusivePtr

friend

Referenced by inet::IntrusivePtr< T >::operator=(), and inet::IntrusivePtr< T >::reset().

Member Data Documentation

p

template<class T >

T* inet::IntrusivePtr< T >::p

private

Referenced by inet::IntrusivePtr< T >::detach(), inet::IntrusivePtr< T >::get(), inet::IntrusivePtr< T >::IntrusivePtr(), inet::IntrusivePtr< T >::operator bool(), inet::IntrusivePtr< T >::operator*(), inet::IntrusivePtr< T >::operator->(), inet::IntrusivePtr< T >::swap(), inet::IntrusivePtr< T >::use_count(), and inet::IntrusivePtr< T >::~IntrusivePtr().

---

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

• IntrusivePtr.h