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
|
/////////////////////////////////////////////////////////////////////////////
// Name: weakref.h
// Purpose: interface of wxWeakRefDynamic<T>, wxWeakRef<T>
// Author: wxWidgets team
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
/**
wxWeakRefDynamic<T> is a template class for weak references that is used in
the same way as wxWeakRef<T>. The only difference is that wxWeakRefDynamic
defaults to using @c dynamic_cast for establishing the object reference
(while wxWeakRef defaults to @c static_cast).
So, wxWeakRef will detect a type mismatch during compile time and will
have a little better run-time performance. The role of wxWeakRefDynamic
is to handle objects which derived type one does not know.
@note wxWeakRef<T> selects an implementation based on the static type of T.
If T does not have wxTrackable statically, it defaults to a mixed-
mode operation, where it uses @c dynamic_cast as the last measure
(if available from the compiler and enabled when building wxWidgets).
For general cases, wxWeakRef<T> is the better choice.
For API documentation, see: wxWeakRef<T>.
@tparam T
The type to which the smart pointer points to.
@nolibrary
@category{smartpointers}
*/
template<typename T>
class wxWeakRefDynamic<T>
{
public:
};
/**
wxWeakRef<T> is a template class for weak references to wxWidgets objects,
such as wxEvtHandler, wxWindow and wxObject.
A weak reference behaves much like an ordinary pointer, but when the object
pointed is destroyed, the weak reference is automatically reset to a @NULL pointer.
wxWeakRef<T> can be used whenever one must keep a pointer to an object
that one does not directly own, and that may be destroyed before the object
holding the reference.
wxWeakRef<T> is a small object and the mechanism behind it is fast
(@b O(1)). So the overall cost of using it is small.
Example:
@code
wxWindow *wnd = new wxWindow( parent, wxID_ANY, "wxWindow" );
wxWeakRef<wxWindow> wr = wnd;
wxWindowRef wr2 = wnd; // Same as above, but using a typedef
// Do things with window
wnd->Show( true );
// Weak ref is used like an ordinary pointer
wr->Show( false );
wnd->Destroy();
// Now the weak ref has been reset, so we don't risk accessing
// a dangling pointer:
wxASSERT( wr==NULL );
@endcode
wxWeakRef<T> works for any objects that are derived from wxTrackable.
By default, wxEvtHandler and wxWindow derive from wxTrackable.
However, wxObject does not, so types like wxFont and wxColour are not
trackable. The example below shows how to create a wxObject derived class
that is trackable:
@code
class wxMyTrackableObject : public wxObject, public wxTrackable
{
// ... other members here
};
@endcode
The following types of weak references are predefined:
@code
typedef wxWeakRef<wxEvtHandler> wxEvtHandlerRef;
typedef wxWeakRef<wxWindow> wxWindowRef;
@endcode
@tparam T
The type to which the smart pointer points to.
@nolibrary
@category{smartpointers}
@see wxSharedPtr<T>, wxScopedPtr<T>
*/
template<typename T>
class wxWeakRef<T> : public wxTrackerNode
{
public:
/// Type of the element stored by this reference.
typedef T element_type;
/**
Constructor. The weak reference is initialized to @e pobj.
*/
wxWeakRef(T* pobj = NULL);
/**
Copy constructor.
*/
wxWeakRef(const wxWeakRef<T>& wr);
/**
Destructor.
*/
virtual ~wxWeakRef();
/**
Called when the tracked object is destroyed. Be default sets
internal pointer to @NULL.
You need to call this method if you override it.
*/
virtual void OnObjectDestroy();
/**
Release currently tracked object and rests object reference.
*/
void Release();
/**
Returns pointer to the tracked object or @NULL.
*/
T* get() const;
/**
Release currently tracked object and start tracking the same object as
the wxWeakRef @e wr.
*/
T* operator =(wxWeakRef<T>& wr);
/**
Implicit conversion to T*.
Returns pointer to the tracked object or @NULL.
*/
T* operator*() const;
/**
Returns a reference to the tracked object.
If the internal pointer is @NULL this method will cause an assert in debug mode.
*/
T& operator*() const;
/**
Smart pointer member access. Returns a pointer to the tracked object.
If the internal pointer is @NULL this method will cause an assert in debug mode.
*/
T* operator->();
/**
Releases the currently tracked object and starts tracking @e pobj.
A weak reference may be reset by passing @e @NULL as @e pobj.
*/
T* operator=(T* pobj);
};
|
