diff options
Diffstat (limited to 'extra')
| -rw-r--r-- | extra/kde320/ksharedptr.h | 66 | ||||
| -rw-r--r-- | extra/kde321/ksharedptr.h | 66 | ||||
| -rw-r--r-- | extra/kde322/ksharedptr.h | 66 | ||||
| -rw-r--r-- | extra/kde323/ksharedptr.h | 66 | ||||
| -rw-r--r-- | extra/kde330/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde331/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde332/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde340/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde341/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde342/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde343/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde350/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde351/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde352/ksharedptr.h | 68 | ||||
| -rw-r--r-- | extra/kde353/ksharedptr.h | 68 |
15 files changed, 506 insertions, 506 deletions
diff --git a/extra/kde320/ksharedptr.h b/extra/kde320/ksharedptr.h index f8c255b..4dbf558 100644 --- a/extra/kde320/ksharedptr.h +++ b/extra/kde320/ksharedptr.h @@ -15,128 +15,128 @@ 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 /** * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ -class KShared { +class 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 perfectly. So just * use it like a simple C++ pointer. * - * KShared and KSharedPtr are preferred over TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * since they are more safe. * * @author Waldo Bastian <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ template< class T > -struct KSharedPtr +struct 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::_KShared_ref(); } + TDESharedPtr( T* t ) + : ptr(t) { if ( ptr ) ptr->TDEShared::_TDEShared_ref(); } /** * Copies a pointer. * @param p the pointer to copy */ - KSharedPtr( const KSharedPtr& p ) - : ptr(p.ptr) { if ( ptr ) ptr->KShared::_KShared_ref(); } + TDESharedPtr( const TDESharedPtr& p ) + : ptr(p.ptr) { if ( ptr ) ptr->TDEShared::_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::_KShared_unref(); } + ~TDESharedPtr() { if ( ptr ) ptr->TDEShared::_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::_KShared_unref(); + if ( ptr ) ptr->TDEShared::_TDEShared_unref(); ptr = p.ptr; - if ( ptr ) ptr->KShared::_KShared_ref(); + if ( ptr ) ptr->TDEShared::_TDEShared_ref(); return *this; } - KSharedPtr<T>& operator= ( T* p ) { + TDESharedPtr<T>& operator= ( T* p ) { if ( ptr == p ) return *this; - if ( ptr ) ptr->KShared::_KShared_unref(); + if ( ptr ) ptr->TDEShared::_TDEShared_unref(); ptr = p; - if ( ptr ) ptr->KShared::_KShared_ref(); + if ( ptr ) ptr->TDEShared::_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 ); } @@ -163,7 +163,7 @@ public: * Returns the number of references. * @return the number of references */ - int count() const { return ptr->KShared::_KShared_count(); } // for debugging purposes + int count() const { return ptr->TDEShared::_TDEShared_count(); } // for debugging purposes private: T* ptr; }; diff --git a/extra/kde321/ksharedptr.h b/extra/kde321/ksharedptr.h index 238304b..f75ce7b 100644 --- a/extra/kde321/ksharedptr.h +++ b/extra/kde321/ksharedptr.h @@ -15,128 +15,128 @@ 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 /** * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ -class KShared { +class 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 perfectly. So just * use it like a simple C++ pointer. * - * KShared and KSharedPtr are preferred over TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * since they are more safe. * * @author Waldo Bastian <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ template< class T > -struct KSharedPtr +struct 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 ); } @@ -163,7 +163,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; }; diff --git a/extra/kde322/ksharedptr.h b/extra/kde322/ksharedptr.h index 238304b..f75ce7b 100644 --- a/extra/kde322/ksharedptr.h +++ b/extra/kde322/ksharedptr.h @@ -15,128 +15,128 @@ 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 /** * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ -class KShared { +class 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 perfectly. So just * use it like a simple C++ pointer. * - * KShared and KSharedPtr are preferred over TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * since they are more safe. * * @author Waldo Bastian <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ template< class T > -struct KSharedPtr +struct 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 ); } @@ -163,7 +163,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; }; diff --git a/extra/kde323/ksharedptr.h b/extra/kde323/ksharedptr.h index 238304b..f75ce7b 100644 --- a/extra/kde323/ksharedptr.h +++ b/extra/kde323/ksharedptr.h @@ -15,128 +15,128 @@ 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 /** * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ -class KShared { +class 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 perfectly. So just * use it like a simple C++ pointer. * - * KShared and KSharedPtr are preferred over TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * since they are more safe. * * @author Waldo Bastian <[email protected]> * @version $Id: ksharedptr.h,v 1.22 2003/08/20 08:01:42 coolo Exp $ */ template< class T > -struct KSharedPtr +struct 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 ); } @@ -163,7 +163,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; }; diff --git a/extra/kde330/ksharedptr.h b/extra/kde330/ksharedptr.h index 2b124ed..204ea4d 100644 --- a/extra/kde330/ksharedptr.h +++ b/extra/kde330/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 /** * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $ */ -class KShared { +class 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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $ */ template< class T > -struct KSharedPtr +struct 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; }; diff --git a/extra/kde331/ksharedptr.h b/extra/kde331/ksharedptr.h index 2b124ed..204ea4d 100644 --- a/extra/kde331/ksharedptr.h +++ b/extra/kde331/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 /** * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $ */ -class KShared { +class 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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $ */ template< class T > -struct KSharedPtr +struct 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; }; diff --git a/extra/kde332/ksharedptr.h b/extra/kde332/ksharedptr.h index 2b124ed..204ea4d 100644 --- a/extra/kde332/ksharedptr.h +++ b/extra/kde332/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 /** * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $ */ -class KShared { +class 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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> * @version $Id: ksharedptr.h,v 1.23 2004/02/04 12:16:03 raabe Exp $ */ template< class T > -struct KSharedPtr +struct 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; }; diff --git a/extra/kde340/ksharedptr.h b/extra/kde340/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde340/ksharedptr.h +++ b/extra/kde340/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; diff --git a/extra/kde341/ksharedptr.h b/extra/kde341/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde341/ksharedptr.h +++ b/extra/kde341/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; diff --git a/extra/kde342/ksharedptr.h b/extra/kde342/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde342/ksharedptr.h +++ b/extra/kde342/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; diff --git a/extra/kde343/ksharedptr.h b/extra/kde343/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde343/ksharedptr.h +++ b/extra/kde343/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; diff --git a/extra/kde350/ksharedptr.h b/extra/kde350/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde350/ksharedptr.h +++ b/extra/kde350/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; diff --git a/extra/kde351/ksharedptr.h b/extra/kde351/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde351/ksharedptr.h +++ b/extra/kde351/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; diff --git a/extra/kde352/ksharedptr.h b/extra/kde352/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde352/ksharedptr.h +++ b/extra/kde352/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; diff --git a/extra/kde353/ksharedptr.h b/extra/kde353/ksharedptr.h index 4d19652..772146f 100644 --- a/extra/kde353/ksharedptr.h +++ b/extra/kde353/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 <[email protected]> */ -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 TQShared / TQSharedPtr + * TDEShared and TDESharedPtr are preferred over TQShared / TQSharedPtr * 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 <[email protected]> */ 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; }; |