From 12f3d421cd2991c0e3f96994efb836ce244172ff Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Thu, 31 Jan 2013 00:36:34 -0600 Subject: Rename KShared --- tdecore/ksharedptr.h | 68 ++++++++++++++++++++++++++-------------------------- 1 file changed, 34 insertions(+), 34 deletions(-) (limited to 'tdecore/ksharedptr.h') diff --git a/tdecore/ksharedptr.h b/tdecore/ksharedptr.h index 16ece722c..60a06a55f 100644 --- a/tdecore/ksharedptr.h +++ b/tdecore/ksharedptr.h @@ -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 */ -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 */ 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& operator= ( const KSharedPtr& p ) { + TDESharedPtr& operator= ( const TDESharedPtr& 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& operator= ( T* p ) { + TDESharedPtr& 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& p ) const { return ( ptr == p.ptr ); } - bool operator!= ( const KSharedPtr& p ) const { return ( ptr != p.ptr ); } + bool operator== ( const TDESharedPtr& p ) const { return ( ptr == p.ptr ); } + bool operator!= ( const TDESharedPtr& 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; }; -- cgit v1.2.3