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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
// Copyright (C) 2007 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#undef DLIB_WEAK_PTr_ABSTRACT_
#ifdef DLIB_WEAK_PTr_ABSTRACT_
#include "shared_ptr_abstract.h"
namespace dlib {
template <
typename T
>
class weak_ptr
{
/*!
INITIAL VALUE
defined by constructor
WHAT THIS OBJECT REPRESENTS
The weak_ptr class template stores a weak reference to an object that is
already managed by a shared_ptr. To access the object, a weak_ptr can
be converted to a shared_ptr using the member function lock().
This is an implementation of the std::tr1::weak_ptr template from the
document ISO/IEC PDTR 19768, Proposed Draft Technical Report on C++
Library Extensions. The only deviation from that document is that this
shared_ptr is declared inside the dlib namespace rather than std::tr1.
!*/
public:
typedef T element_type;
weak_ptr(
);
/*!
ensures
- #use_count() == 0
- creates an empty weak_ptr
!*/
template<typename Y>
weak_ptr(
const shared_ptr<Y>& r
);
/*!
requires
- Y* must be convertible to T*
ensures
- if (r is empty) then
- constructs an empty weak_ptr object
- else
- constructs a weak_ptr object that shares ownership with r and
stores a copy of the pointer stored in r.
- #use_count() == #r.use_count()
!*/
weak_ptr(
const weak_ptr& r
);
/*!
ensures
- if (r is empty) then
- constructs an empty weak_ptr object
- else
- constructs a weak_ptr object that shares ownership with r and
stores a copy of the pointer stored in r.
- #use_count() == #r.use_count()
!*/
template<typename Y>
weak_ptr(
const weak_ptr<Y>& r
);
/*!
requires
- Y* must be convertible to T*
ensures
- if (r is empty) then
- constructs an empty weak_ptr object
- else
- constructs a weak_ptr object that shares ownership with r and
stores a copy of the pointer stored in r.
- #use_count() == #r.use_count()
!*/
~weak_ptr(
);
/*!
ensures
- destroys this weak_ptr object but has no effect on the object its
stored pointer points to.
!*/
weak_ptr& operator= (
const weak_ptr& r
);
/*!
ensures
- equivalent to weak_ptr(r).swap(*this)
!*/
template<typename Y>
weak_ptr& operator= (
const weak_ptr<Y>& r
);
/*!
requires
- Y* must be convertible to T*
ensures
- equivalent to weak_ptr(r).swap(*this)
!*/
template<typename Y>
weak_ptr& operator=(
const shared_ptr<Y>& r
);
/*!
requires
- Y* must be convertible to T*
ensures
- equivalent to weak_ptr(r).swap(*this)
!*/
long use_count(
) const;
/*!
ensures
- if (*this is empty) then
- returns 0
- else
- returns the number of shared_ptr instances that share ownership
with *this
!*/
bool expired(
) const;
/*!
ensures
- returns (use_count() == 0)
!*/
shared_ptr<T> lock(
) const;
/*!
ensures
- if (expired()) then
- returns shared_ptr<T>()
- else
- returns shared_ptr<T>(*this)
!*/
void reset(
);
/*!
ensures
- equivalent to weak_ptr().swap(*this)
!*/
void swap(
weak_ptr<T>& b
);
/*!
ensures
- swaps *this and item
!*/
};
template<typename T, typename U>
bool operator< (
const weak_ptr<T>& a,
const weak_ptr<U>& b
);
/*!
ensures
- Defines an operator< on shared_ptr types appropriate for use in the associative
containers.
!*/
template<typename T>
void swap(
weak_ptr<T>& a,
weak_ptr<T> & b
) { a.swap(b); }
/*!
provides a global swap function
!*/
}
#endif // DLIB_WEAK_PTr_ABSTRACT_
|
