|
|
|
|
@ -15,132 +15,132 @@
|
|
|
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
|
|
|
Boston, MA 02110-1301, USA.
|
|
|
|
|
*/
|
|
|
|
|
#ifndef KSharedPTR_H
|
|
|
|
|
#define KSharedPTR_H
|
|
|
|
|
#ifndef TDESharedPTR_H
|
|
|
|
|
#define TDESharedPTR_H
|
|
|
|
|
|
|
|
|
|
#include "tdelibs_export.h"
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Reference counting for shared objects. If you derive your object
|
|
|
|
|
* from this class, then you may use it in conjunction with
|
|
|
|
|
* KSharedPtr to control the lifetime of your object.
|
|
|
|
|
* TDESharedPtr to control the lifetime of your object.
|
|
|
|
|
*
|
|
|
|
|
* Specifically, all classes that derive from KShared have an internal
|
|
|
|
|
* Specifically, all classes that derive from TDEShared have an internal
|
|
|
|
|
* counter keeping track of how many other objects have a reference to
|
|
|
|
|
* their object. If used with KSharedPtr, then your object will
|
|
|
|
|
* their object. If used with TDESharedPtr, then your object will
|
|
|
|
|
* not be deleted until all references to the object have been
|
|
|
|
|
* released.
|
|
|
|
|
*
|
|
|
|
|
* You should probably not ever use any of the methods in this class
|
|
|
|
|
* directly -- let the KSharedPtr take care of that. Just derive
|
|
|
|
|
* your class from KShared and forget about it.
|
|
|
|
|
* directly -- let the TDESharedPtr take care of that. Just derive
|
|
|
|
|
* your class from TDEShared and forget about it.
|
|
|
|
|
*
|
|
|
|
|
* @author Waldo Bastian <bastian@kde.org>
|
|
|
|
|
*/
|
|
|
|
|
class TDECORE_EXPORT KShared {
|
|
|
|
|
class TDECORE_EXPORT TDEShared {
|
|
|
|
|
public:
|
|
|
|
|
/**
|
|
|
|
|
* Standard constructor. This will initialize the reference count
|
|
|
|
|
* on this object to 0.
|
|
|
|
|
*/
|
|
|
|
|
KShared() : count(0) { }
|
|
|
|
|
TDEShared() : count(0) { }
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Copy constructor. This will @em not actually copy the objects
|
|
|
|
|
* but it will initialize the reference count on this object to 0.
|
|
|
|
|
*/
|
|
|
|
|
KShared( const KShared & ) : count(0) { }
|
|
|
|
|
TDEShared( const TDEShared & ) : count(0) { }
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Overloaded assignment operator.
|
|
|
|
|
*/
|
|
|
|
|
KShared &operator=(const KShared & ) { return *this; }
|
|
|
|
|
TDEShared &operator=(const TDEShared & ) { return *this; }
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Increases the reference count by one.
|
|
|
|
|
*/
|
|
|
|
|
void _KShared_ref() const { count++; }
|
|
|
|
|
void _TDEShared_ref() const { count++; }
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Releases a reference (decreases the reference count by one). If
|
|
|
|
|
* the count goes to 0, this object will delete itself.
|
|
|
|
|
*/
|
|
|
|
|
void _KShared_unref() const { if (!--count) delete this; }
|
|
|
|
|
void _TDEShared_unref() const { if (!--count) delete this; }
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Return the current number of references held.
|
|
|
|
|
*
|
|
|
|
|
* @return Number of references
|
|
|
|
|
*/
|
|
|
|
|
int _KShared_count() const { return count; }
|
|
|
|
|
int _TDEShared_count() const { return count; }
|
|
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
virtual ~KShared() { }
|
|
|
|
|
virtual ~TDEShared() { }
|
|
|
|
|
private:
|
|
|
|
|
mutable int count;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Can be used to control the lifetime of an object that has derived
|
|
|
|
|
* KShared. As long a someone holds a KSharedPtr on some KShared
|
|
|
|
|
* TDEShared. As long a someone holds a TDESharedPtr on some TDEShared
|
|
|
|
|
* object it won't become deleted but is deleted once its reference
|
|
|
|
|
* count is 0. This struct emulates C++ pointers virtually perfectly.
|
|
|
|
|
* So just use it like a simple C++ pointer.
|
|
|
|
|
*
|
|
|
|
|
* KShared and KSharedPtr are preferred over QShared / QSharedPtr
|
|
|
|
|
* TDEShared and TDESharedPtr are preferred over QShared / QSharedPtr
|
|
|
|
|
* since they are more safe.
|
|
|
|
|
*
|
|
|
|
|
* WARNING: Please note that this class template provides an implicit
|
|
|
|
|
* conversion to T*. Do *not* change this pointer or the pointee (don't
|
|
|
|
|
* call delete on it, for instance) behind KSharedPtr's back.
|
|
|
|
|
* call delete on it, for instance) behind TDESharedPtr's back.
|
|
|
|
|
*
|
|
|
|
|
* @author Waldo Bastian <bastian@kde.org>
|
|
|
|
|
*/
|
|
|
|
|
template< class T >
|
|
|
|
|
class KSharedPtr
|
|
|
|
|
class TDESharedPtr
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
/**
|
|
|
|
|
* Creates a null pointer.
|
|
|
|
|
*/
|
|
|
|
|
KSharedPtr()
|
|
|
|
|
TDESharedPtr()
|
|
|
|
|
: ptr(0) { }
|
|
|
|
|
/**
|
|
|
|
|
* Creates a new pointer.
|
|
|
|
|
* @param t the pointer
|
|
|
|
|
*/
|
|
|
|
|
KSharedPtr( T* t )
|
|
|
|
|
: ptr(t) { if ( ptr ) ptr->_KShared_ref(); }
|
|
|
|
|
TDESharedPtr( T* t )
|
|
|
|
|
: ptr(t) { if ( ptr ) ptr->_TDEShared_ref(); }
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Copies a pointer.
|
|
|
|
|
* @param p the pointer to copy
|
|
|
|
|
*/
|
|
|
|
|
KSharedPtr( const KSharedPtr& p )
|
|
|
|
|
: ptr(p.ptr) { if ( ptr ) ptr->_KShared_ref(); }
|
|
|
|
|
TDESharedPtr( const TDESharedPtr& p )
|
|
|
|
|
: ptr(p.ptr) { if ( ptr ) ptr->_TDEShared_ref(); }
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Unreferences the object that this pointer points to. If it was
|
|
|
|
|
* the last reference, the object will be deleted.
|
|
|
|
|
*/
|
|
|
|
|
~KSharedPtr() { if ( ptr ) ptr->_KShared_unref(); }
|
|
|
|
|
~TDESharedPtr() { if ( ptr ) ptr->_TDEShared_unref(); }
|
|
|
|
|
|
|
|
|
|
KSharedPtr<T>& operator= ( const KSharedPtr<T>& p ) {
|
|
|
|
|
TDESharedPtr<T>& operator= ( const TDESharedPtr<T>& p ) {
|
|
|
|
|
if ( ptr == p.ptr ) return *this;
|
|
|
|
|
if ( ptr ) ptr->_KShared_unref();
|
|
|
|
|
if ( ptr ) ptr->_TDEShared_unref();
|
|
|
|
|
ptr = p.ptr;
|
|
|
|
|
if ( ptr ) ptr->_KShared_ref();
|
|
|
|
|
if ( ptr ) ptr->_TDEShared_ref();
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
KSharedPtr<T>& operator= ( T* p ) {
|
|
|
|
|
TDESharedPtr<T>& operator= ( T* p ) {
|
|
|
|
|
if ( ptr == p ) return *this;
|
|
|
|
|
if ( ptr ) ptr->_KShared_unref();
|
|
|
|
|
if ( ptr ) ptr->_TDEShared_unref();
|
|
|
|
|
ptr = p;
|
|
|
|
|
if ( ptr ) ptr->_KShared_ref();
|
|
|
|
|
if ( ptr ) ptr->_TDEShared_ref();
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
bool operator== ( const KSharedPtr<T>& p ) const { return ( ptr == p.ptr ); }
|
|
|
|
|
bool operator!= ( const KSharedPtr<T>& p ) const { return ( ptr != p.ptr ); }
|
|
|
|
|
bool operator== ( const TDESharedPtr<T>& p ) const { return ( ptr == p.ptr ); }
|
|
|
|
|
bool operator!= ( const TDESharedPtr<T>& p ) const { return ( ptr != p.ptr ); }
|
|
|
|
|
bool operator== ( const T* p ) const { return ( ptr == p ); }
|
|
|
|
|
bool operator!= ( const T* p ) const { return ( ptr != p ); }
|
|
|
|
|
bool operator!() const { return ( ptr == 0 ); }
|
|
|
|
|
@ -167,7 +167,7 @@ public:
|
|
|
|
|
* Returns the number of references.
|
|
|
|
|
* @return the number of references
|
|
|
|
|
*/
|
|
|
|
|
int count() const { return ptr->_KShared_count(); } // for debugging purposes
|
|
|
|
|
int count() const { return ptr->_TDEShared_count(); } // for debugging purposes
|
|
|
|
|
private:
|
|
|
|
|
T* ptr;
|
|
|
|
|
};
|
|
|
|
|
|
Timothy Pearson
12 years ago