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
|
/*
* This file is part of the KDE Libraries
* Copyright (C) 2000 Stephan Kulow <coolo@kde.org>
* 2001 KDE Team
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* 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 _KSTATIC_DELETER_H_
#define _KSTATIC_DELETER_H_
#include <kglobal.h>
/**
* Static deleters are used to manage static resources. They can register
* themselves with KGlobal. KGlobal will call destructObject() when
* KGlobal::deleteStaticDeleters() is called or when it the process
* finishes.
*
* @see KStaticDeleter
* @see KGlobal::registerStaticDeleter()
* @see KGlobal::unregisterStaticDeleter()
* @see KGlobal::deleteStaticDeleters()
*/
class KDECORE_EXPORT KStaticDeleterBase {
public:
virtual ~KStaticDeleterBase() { }
/**
* Should destruct the resources managed by this KStaticDeleterBase.
* Usually you also want to call it in your destructor.
* @see KGlobal::deleteStaticDeleters()
*/
virtual void destructObject();
};
/**
* Little helper class to clean up static objects that are
* held as pointer.
* When the library is unloaded, or the app terminated, all static deleters
* are destroyed, which in turn destroys those static objects properly.
* There are some rules which you should accept in the KStaticDeleter managed
* class:
* @li Don't rely on the global reference variable in the destructor of the
* object, it will be '0' at destruction time.
* @li Don't rely on other KStaticDeleter managed objects in the destructor
* of the object, because it may be destroyed before your destructor get called.
* This one can be tricky, because you might not know that you actually use a
* KStaticDeleter managed class. So try to keep your destructor simple.
*
* A typical use is
* \code
* static KStaticDeleter<MyClass> sd;
*
* MyClass &MyClass::self() {
* if (!_self) { sd.setObject(_self, new MyClass()); }
* return *_self;
* }
* \endcode
*/
template<class type> class KStaticDeleter : public KStaticDeleterBase {
public:
KStaticDeleter() { deleteit = 0; globalReference = 0; array = false; }
/**
* Sets the object to delete and registers the object to be
* deleted to KGlobal. If the given object is 0, the former
* registration is unregistered.
* @param obj the object to delete
* @param isArray tells the destructor to delete an array instead of an object
* @deprecated See the other setObject variant.
**/
KDE_DEPRECATED type *setObject( type *obj, bool isArray = false) {
deleteit = obj;
globalReference = 0;
array = isArray;
if (obj)
KGlobal::registerStaticDeleter(this);
else
KGlobal::unregisterStaticDeleter(this);
return obj;
}
/**
* Sets the object to delete and registers the object to be
* deleted to KGlobal. If the given object is 0, the former
* registration is unregistered.
* @param globalRef the static pointer where this object is stored
* This pointer will be reset to 0 after deletion of the object.
* @param obj the object to delete
* @param isArray tells the destructor to delete an array instead of an object
**/
type *setObject( type* & globalRef, type *obj, bool isArray = false) {
globalReference = &globalRef;
deleteit = obj;
array = isArray;
if (obj)
KGlobal::registerStaticDeleter(this);
else
KGlobal::unregisterStaticDeleter(this);
globalRef = obj;
return obj;
}
/**
* Destructs the object. This has the same effect as deleting
* the KStaticDeleter.
*/
virtual void destructObject() {
if (globalReference)
*globalReference = 0;
if (array)
delete [] deleteit;
else
delete deleteit;
deleteit = 0;
}
virtual ~KStaticDeleter() {
KGlobal::unregisterStaticDeleter(this);
destructObject();
}
private:
type *deleteit;
type **globalReference;
bool array;
};
#endif
|
