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 <[email protected]>
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 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
* TDESharedPtr to control the lifetime of your object.
*
* 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 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 TDESharedPtr take care of that. Just derive
* your class from TDEShared and forget about it.
*
* @author Waldo Bastian <[email protected]>
*/
class TDECORE_EXPORT TDEShared {
public:
/**
* Standard constructor. This will initialize the reference count
* on this object to 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.
*/
TDEShared( const TDEShared & ) : count(0) { }
/**
* Overloaded assignment operator.
*/
TDEShared &operator=(const TDEShared & ) { return *this; }
/**
* Increases the reference count by one.
*/
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 _TDEShared_unref() const { if (!--count) delete this; }
/**
* Return the current number of references held.
*
* @return Number of references
*/
int _TDEShared_count() const { return count; }
protected:
virtual ~TDEShared() { }
private:
mutable int count;
};
/**
* Can be used to control the lifetime of an object that has derived
* 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.
*
* 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 TDESharedPtr's back.
*
* @author Waldo Bastian <[email protected]>
*/
template< class T >
class TDESharedPtr
{
public:
/**
* Creates a null pointer.
*/
TDESharedPtr()
: ptr(0) { }
/**
* Creates a new pointer.
* @param t the pointer
*/
TDESharedPtr( T* t )
: ptr(t) { if ( ptr ) ptr->_TDEShared_ref(); }
/**
* Copies a pointer.
* @param p the pointer to copy
*/
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.
*/
~TDESharedPtr() { if ( ptr ) ptr->_TDEShared_unref(); }
TDESharedPtr<T>& operator= ( const TDESharedPtr<T>& p ) {
if ( ptr == p.ptr ) return *this;
if ( ptr ) ptr->_TDEShared_unref();
ptr = p.ptr;
if ( ptr ) ptr->_TDEShared_ref();
return *this;
}
TDESharedPtr<T>& operator= ( T* p ) {
if ( ptr == p ) return *this;
if ( ptr ) ptr->_TDEShared_unref();
ptr = p;
if ( ptr ) ptr->_TDEShared_ref();
return *this;
}
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 ); }
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->_TDEShared_count(); } // for debugging purposes
private:
T* ptr;
};
#endif
|
