#include <kis_shared_ptr.h>

Inheritance diagram for KisSharedPtr< T >:

Public Types
using	element_type = T

using	weak_type = KisWeakSharedPtr<T>

Public Member Functions
void	attach (T *p)

void	clear ()

const T *	constData () const

T *	data ()

const T *	data () const

bool	isNull () const

	KisSharedPtr ()

	KisSharedPtr (const KisSharedPtr< T > &o)

	KisSharedPtr (const KisWeakSharedPtr< T > &o)

	KisSharedPtr (T *p)

	operator const T * () const

template<class T2 >
	operator KisSharedPtr< T2 > () const

bool	operator!= (const KisSharedPtr &o) const

bool	operator!= (const T *p) const

T &	operator* ()

const T &	operator* () const

T *	operator-> ()

const T *	operator-> () const

KisSharedPtr &	operator= (const KisSharedPtr &o)

KisSharedPtr< T > &	operator= (T *p)

bool	operator== (const KisSharedPtr &o) const

bool	operator== (const T *p) const

	~KisSharedPtr ()

Static Public Member Functions
static bool	deref (const KisSharedPtr< T > sp, T t)

static void	ref (const KisSharedPtr< T > sp, T t)

Private Member Functions
void	deref () const

void	ref () const

Private Attributes
T *	d

Friends
class	KisWeakSharedPtr< T >

Detailed Description

template<class T>
class KisSharedPtr< T >

KisSharedPtr is a shared pointer similar to KSharedPtr and boost::shared_ptr. The difference with KSharedPtr is that our constructor is not explicit.

A shared pointer is a wrapper around a real pointer. The shared pointer keeps a reference count, and when the reference count drops to 0 the contained pointer is deleted. You can use the shared pointer just as you would use a real pointer.

See also item 28 and 29 of More Effective C++ and https://bugs.kde.org/show_bug.cgi?id=52261 as well as https://www.boost.org/libs/smart_ptr/shared_ptr.htm.

Advantage of KisSharedPtr over boost pointer or QSharedPointer?

The difference with boost share pointer is that in boost::shared_ptr, the counter is kept inside the smart pointer, meaning that you should never never remove the pointer from its smart pointer object, because if you do that, and somewhere in the code, the pointer is put back in a smart pointer, then you have two counters, and when one reach zero, then the object gets deleted while some other code thinks the pointer is still valid.

Disadvantage of KisSharedPtr compared to boost pointer?

KisSharedPtr requires the class to inherits KisShared.

Difference with QSharedPointer

QSharedPointer and KisSharedPtr are very similar, but QSharedPointer has an explicit constructor which makes it more painful to use in some constructions. And QSharedPointer doesn't offer a weak pointer.

Definition at line 56 of file kis_shared_ptr.h.

Member Typedef Documentation

◆ element_type

template<class T >

using KisSharedPtr< T >::element_type = T

Definition at line 60 of file kis_shared_ptr.h.

◆ weak_type

template<class T >

using KisSharedPtr< T >::weak_type = KisWeakSharedPtr<T>

Definition at line 61 of file kis_shared_ptr.h.

Constructor & Destructor Documentation

◆ KisSharedPtr() [1/4]

template<class T >

KisSharedPtr< T >::KisSharedPtr ( )

inline

Creates a null pointer.

Definition at line 66 of file kis_shared_ptr.h.

67 : d(0) { }

KisSharedPtr::d

T * d

Definition kis_shared_ptr.h:227

◆ KisSharedPtr() [2/4]

template<class T >

KisSharedPtr< T >::KisSharedPtr ( T * p )

inline

Creates a new pointer.

Parameters

p	the pointer

Definition at line 73 of file kis_shared_ptr.h.

            : d(p) {
        ref();
    }

References KisSharedPtr< T >::ref().

◆ KisSharedPtr() [3/4]

template<class T >

Q_INLINE_TEMPLATE KisSharedPtr< T >::KisSharedPtr ( const KisWeakSharedPtr< T > & o )

inline

Thread safety: Is the object we have just referenced still valid?

Definition at line 484 of file kis_shared_ptr.h.

        : d(o.d)
{
    if (o.isValid()) {
        ref();
 
        Q_ASSERT(o.isConsistent());
    }
    else {
        d = 0;
    }
}

References KisSharedPtr< T >::d, and KisSharedPtr< T >::ref().

◆ KisSharedPtr() [4/4]

template<class T >

KisSharedPtr< T >::KisSharedPtr ( const KisSharedPtr< T > & o )

inline

Copies a pointer.

Parameters

o	the pointer to copy

Definition at line 90 of file kis_shared_ptr.h.

            : d(o.d) {
        ref();
    }

References KisSharedPtr< T >::ref().

◆ ~KisSharedPtr()

template<class T >

KisSharedPtr< T >::~KisSharedPtr ( )

inline

Dereferences the object that this pointer points to. If it was the last reference, the object will be deleted.

Definition at line 99 of file kis_shared_ptr.h.

                           {
        deref();
    }

References KisSharedPtr< T >::deref().

Member Function Documentation

◆ attach()

template<class T >

Q_INLINE_TEMPLATE void KisSharedPtr< T >::attach ( T * p )

Definition at line 503 of file kis_shared_ptr.h.

{
    if (d != p) {
        ref(this, p);
        T* old = d;
        d = p;
        deref(this, old);
    }
}

References KisSharedPtr< T >::d, KisSharedPtr< T >::deref(), p, and KisSharedPtr< T >::ref().

◆ clear()

template<class T >

Q_INLINE_TEMPLATE void KisSharedPtr< T >::clear ( )

Definition at line 514 of file kis_shared_ptr.h.

{
    attach((T*)0);
}

References KisSharedPtr< T >::attach().

◆ constData()

template<class T >

const T * KisSharedPtr< T >::constData ( ) const

inline

Returns: a const pointer to the shared object.

Definition at line 153 of file kis_shared_ptr.h.

                                      {
        return d;
    }

References KisSharedPtr< T >::d.

◆ data() [1/2]

template<class T >

T * KisSharedPtr< T >::data ( )

inline

Returns: the contained pointer. If you delete the contained pointer, you will make KisSharedPtr very unhappy. It is perfectly safe to put the contained pointer in another KisSharedPtr, though.

Definition at line 139 of file kis_shared_ptr.h.

                     {
        return d;
    }

References KisSharedPtr< T >::d.

◆ data() [2/2]

template<class T >

const T * KisSharedPtr< T >::data ( ) const

inline

Returns: the pointer

Definition at line 146 of file kis_shared_ptr.h.

                                 {
        return d;
    }

References KisSharedPtr< T >::d.

◆ deref() [1/2]

template<class T >

void KisSharedPtr< T >::deref ( ) const

inlineprivate

Definition at line 214 of file kis_shared_ptr.h.

    {
        bool v = deref(this, d);
#ifndef NDEBUG
        if (!v) {
            d = 0;
        }
#else
    Q_UNUSED(v);
#endif
    }

References KisSharedPtr< T >::d, KisSharedPtr< T >::deref(), and v.

◆ deref() [2/2]

template<class T >

static bool KisSharedPtr< T >::deref	(	const KisSharedPtr< T > *	sp,
		T *	t )

inlinestatic

Definition at line 194 of file kis_shared_ptr.h.

    {
#ifndef HAVE_MEMORY_LEAK_TRACKER
        Q_UNUSED(sp);
#else
        KisMemoryLeakTracker::instance()->dereference(t, sp);
#endif
        if (t && !t->deref()) {
            delete t;
            return false;
        }
        return true;
    }

References KisMemoryLeakTracker::dereference(), and KisMemoryLeakTracker::instance().

◆ isNull()

template<class T >

bool KisSharedPtr< T >::isNull ( ) const

inline

Returns: true if the pointer is null

Definition at line 178 of file kis_shared_ptr.h.

                               {
        return (d == 0);
    }

References KisSharedPtr< T >::d.

◆ operator const T *()

template<class T >

KisSharedPtr< T >::operator const T * ( ) const

inline

Definition at line 125 of file kis_shared_ptr.h.

                                     {
        return d;
    }

◆ operator KisSharedPtr< T2 >()

template<class T >

template<class T2 >

KisSharedPtr< T >::operator KisSharedPtr< T2 > ( ) const

inline

Definition at line 129 of file kis_shared_ptr.h.

                                                                 {
        return KisSharedPtr<T2>(d);
    }

References KisSharedPtr< T >::d.

◆ operator!=() [1/2]

template<class T >

bool KisSharedPtr< T >::operator!= ( const KisSharedPtr< T > & o ) const

inline

Definition at line 116 of file kis_shared_ptr.h.

                                                         {
        return (d != o.d);
    }

References KisSharedPtr< T >::d.

◆ operator!=() [2/2]

template<class T >

bool KisSharedPtr< T >::operator!= ( const T * p ) const

inline

Definition at line 110 of file kis_shared_ptr.h.

                                              {
        return (d != p);
    }

References KisSharedPtr< T >::d, and p.

◆ operator*() [1/2]

template<class T >

T & KisSharedPtr< T >::operator* ( )

inline

Definition at line 161 of file kis_shared_ptr.h.

                          {
        Q_ASSERT(d);
        return *d;
    }

References KisSharedPtr< T >::d.

◆ operator*() [2/2]

template<class T >

const T & KisSharedPtr< T >::operator* ( ) const

inline

Definition at line 157 of file kis_shared_ptr.h.

                                      {
        Q_ASSERT(d);
        return *d;
    }

References KisSharedPtr< T >::d.

◆ operator->() [1/2]

template<class T >

T * KisSharedPtr< T >::operator-> ( )

inline

Definition at line 170 of file kis_shared_ptr.h.

                           {
        Q_ASSERT(d);
        return d;
    }

References KisSharedPtr< T >::d.

◆ operator->() [2/2]

template<class T >

const T * KisSharedPtr< T >::operator-> ( ) const

inline

Definition at line 166 of file kis_shared_ptr.h.

                                       {
        Q_ASSERT(d);
        return d;
    }

References KisSharedPtr< T >::d.

◆ operator=() [1/2]

template<class T >

KisSharedPtr & KisSharedPtr< T >::operator= ( const KisSharedPtr< T > & o )

inline

Definition at line 103 of file kis_shared_ptr.h.

                                                           {
        attach(o.d);
        return *this;
    }

References KisSharedPtr< T >::attach().

◆ operator=() [2/2]

template<class T >

KisSharedPtr< T > & KisSharedPtr< T >::operator= ( T * p )

inline

Definition at line 120 of file kis_shared_ptr.h.

                                             {
        attach(p);
        return *this;
    }

References KisSharedPtr< T >::attach(), and p.

◆ operator==() [1/2]

template<class T >

bool KisSharedPtr< T >::operator== ( const KisSharedPtr< T > & o ) const

inline

Definition at line 113 of file kis_shared_ptr.h.

                                                         {
        return (d == o.d);
    }

References KisSharedPtr< T >::d.

◆ operator==() [2/2]

template<class T >

bool KisSharedPtr< T >::operator== ( const T * p ) const

inline

Definition at line 107 of file kis_shared_ptr.h.

                                              {
        return (d == p);
    }

References KisSharedPtr< T >::d, and p.

◆ ref() [1/2]

template<class T >

void KisSharedPtr< T >::ref ( ) const

inlineprivate

Definition at line 209 of file kis_shared_ptr.h.

    {
        ref(this, d);
    }

References KisSharedPtr< T >::d, and KisSharedPtr< T >::ref().

◆ ref() [2/2]

template<class T >

static void KisSharedPtr< T >::ref	(	const KisSharedPtr< T > *	sp,
		T *	t )

inlinestatic

Definition at line 182 of file kis_shared_ptr.h.

    {
#ifndef HAVE_MEMORY_LEAK_TRACKER
        Q_UNUSED(sp);
#else
        KisMemoryLeakTracker::instance()->reference(t, sp);
#endif
        if (t) {
            t->ref();
        }
    }

References KisMemoryLeakTracker::instance(), and KisMemoryLeakTracker::reference().

Friends And Related Symbol Documentation

◆ KisWeakSharedPtr< T >

template<class T >

friend class KisWeakSharedPtr< T >

friend

Definition at line 514 of file kis_shared_ptr.h.

Member Data Documentation

◆ d

template<class T >

T* KisSharedPtr< T >::d

mutableprivate

Definition at line 227 of file kis_shared_ptr.h.

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

libs/global/kis_pointer_utils.h
libs/global/kis_shared_ptr.h

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ element_type

◆ weak_type

Constructor & Destructor Documentation

◆ KisSharedPtr() [1/4]

◆ KisSharedPtr() [2/4]

◆ KisSharedPtr() [3/4]

◆ KisSharedPtr() [4/4]

◆ ~KisSharedPtr()

Member Function Documentation

◆ attach()

◆ clear()

◆ constData()

◆ data() [1/2]

◆ data() [2/2]

◆ deref() [1/2]

◆ deref() [2/2]

◆ isNull()

◆ operator const T *()

◆ operator KisSharedPtr< T2 >()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator->() [1/2]

◆ operator->() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ ref() [1/2]

◆ ref() [2/2]

Friends And Related Symbol Documentation

◆ KisWeakSharedPtr< T >

Member Data Documentation

◆ d