summaryrefslogtreecommitdiffstats
path: root/tdecore/ksharedptr.h
diff options
context:
space:
mode:
Diffstat (limited to 'tdecore/ksharedptr.h')
-rw-r--r--tdecore/ksharedptr.h68
1 files changed, 34 insertions, 34 deletions
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 <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;
};