1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/* This file is part of the KDE libraries
Copyright (c) 1999 Waldo Bastian <bastian@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef KSharedPTR_H
#define KSharedPTR_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.
*
* Specifically, all classes that derive from KShared 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
* 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.
*
* @author Waldo Bastian <bastian@kde.org>
*/
class TDECORE_EXPORT KShared {
public:
/**
* Standard constructor. This will initialize the reference count
* on this object to 0.
*/
KShared() : 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) { }
/**
* Overloaded assignment operator.
*/
KShared &operator=(const KShared & ) { return *this; }
/**
* Increases the reference count by one.
*/
void _KShared_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; }
/**
* Return the current number of references held.
*
* @return Number of references
*/
int _KShared_count() const { return count; }
protected:
virtual ~KShared() { }
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
* 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
* 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.
*
* @author Waldo Bastian <bastian@kde.org>
*/
template< class T >
class KSharedPtr
{
public:
/**
* Creates a null pointer.
*/
KSharedPtr()
: ptr(0) { }
/**
* Creates a new pointer.
* @param t the pointer
*/
KSharedPtr( T* t )
: ptr(t) { if ( ptr ) ptr->_KShared_ref(); }
/**
* Copies a pointer.
* @param p the pointer to copy
*/
KSharedPtr( const KSharedPtr& p )
: ptr(p.ptr) { if ( ptr ) ptr->_KShared_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(); }
KSharedPtr<T>& operator= ( const KSharedPtr<T>& p ) {
if ( ptr == p.ptr ) return *this;
if ( ptr ) ptr->_KShared_unref();
ptr = p.ptr;
if ( ptr ) ptr->_KShared_ref();
return *this;
}
KSharedPtr<T>& operator= ( T* p ) {
if ( ptr == p ) return *this;
if ( ptr ) ptr->_KShared_unref();
ptr = p;
if ( ptr ) ptr->_KShared_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 T* p ) const { return ( ptr == p ); }
bool operator!= ( const T* p ) const { return ( ptr != p ); }
bool operator!() const { return ( ptr == 0 ); }
operator T*() const { return ptr; }
/**
* Returns the pointer.
* @return the pointer
*/
T* data() { return ptr; }
/**
* Returns the pointer.
* @return the pointer
*/
const T* data() const { return ptr; }
const T& operator*() const { return *ptr; }
T& operator*() { return *ptr; }
const T* operator->() const { return ptr; }
T* operator->() { return ptr; }
/**
* Returns the number of references.
* @return the number of references
*/
int count() const { return ptr->_KShared_count(); } // for debugging purposes
private:
T* ptr;
};
#endif
|
