1 | |
2 | |
3 | |
4 | |
5 | |
6 | #include "format.h" |
7 | |
8 | #include <algorithm> |
9 | #include <map> |
10 | #include <memory> |
11 | |
12 | #include "utilities/cassandra/serialize.h" |
13 | |
14 | namespace rocksdb { |
15 | namespace cassandra { |
16 | namespace { |
17 | const int32_t kDefaultLocalDeletionTime = |
18 | std::numeric_limits<int32_t>::max(); |
19 | const int64_t kDefaultMarkedForDeleteAt = |
20 | std::numeric_limits<int64_t>::min(); |
21 | } |
22 | |
23 | ColumnBase::ColumnBase(int8_t mask, int8_t index) |
24 | : mask_(mask), index_(index) {} |
25 | |
26 | std::size_t ColumnBase::Size() const { |
27 | return sizeof(mask_) + sizeof(index_); |
28 | } |
29 | |
30 | int8_t ColumnBase::Mask() const { |
31 | return mask_; |
32 | } |
33 | |
34 | int8_t ColumnBase::Index() const { |
35 | return index_; |
36 | } |
37 | |
38 | void ColumnBase::Serialize(std::string* dest) const { |
39 | rocksdb::cassandra::Serialize<int8_t>(mask_, dest); |
40 | rocksdb::cassandra::Serialize<int8_t>(index_, dest); |
41 | } |
42 | |
43 | std::shared_ptr<ColumnBase> ColumnBase::Deserialize(const char* src, |
44 | std::size_t offset) { |
45 | int8_t mask = rocksdb::cassandra::Deserialize<int8_t>(src, offset); |
46 | if ((mask & ColumnTypeMask::DELETION_MASK) != 0) { |
47 | return Tombstone::Deserialize(src, offset); |
48 | } else if ((mask & ColumnTypeMask::EXPIRATION_MASK) != 0) { |
49 | return ExpiringColumn::Deserialize(src, offset); |
50 | } else { |
51 | return Column::Deserialize(src, offset); |
52 | } |
53 | } |
54 | |
55 | Column::Column( |
56 | int8_t mask, |
57 | int8_t index, |
58 | int64_t timestamp, |
59 | int32_t value_size, |
60 | const char* value |
61 | ) : ColumnBase(mask, index), timestamp_(timestamp), |
62 | value_size_(value_size), value_(value) {} |
63 | |
64 | int64_t Column::Timestamp() const { |
65 | return timestamp_; |
66 | } |
67 | |
68 | std::size_t Column::Size() const { |
69 | return ColumnBase::Size() + sizeof(timestamp_) + sizeof(value_size_) |
70 | + value_size_; |
71 | } |
72 | |
73 | void Column::Serialize(std::string* dest) const { |
74 | ColumnBase::Serialize(dest); |
75 | rocksdb::cassandra::Serialize<int64_t>(timestamp_, dest); |
76 | rocksdb::cassandra::Serialize<int32_t>(value_size_, dest); |
77 | dest->append(value_, value_size_); |
78 | } |
79 | |
80 | std::shared_ptr<Column> Column::Deserialize(const char *src, |
81 | std::size_t offset) { |
82 | int8_t mask = rocksdb::cassandra::Deserialize<int8_t>(src, offset); |
83 | offset += sizeof(mask); |
84 | int8_t index = rocksdb::cassandra::Deserialize<int8_t>(src, offset); |
85 | offset += sizeof(index); |
86 | int64_t timestamp = rocksdb::cassandra::Deserialize<int64_t>(src, offset); |
87 | offset += sizeof(timestamp); |
88 | int32_t value_size = rocksdb::cassandra::Deserialize<int32_t>(src, offset); |
89 | offset += sizeof(value_size); |
90 | return std::make_shared<Column>( |
91 | mask, index, timestamp, value_size, src + offset); |
92 | } |
93 | |
94 | ExpiringColumn::ExpiringColumn( |
95 | int8_t mask, |
96 | int8_t index, |
97 | int64_t timestamp, |
98 | int32_t value_size, |
99 | const char* value, |
100 | int32_t ttl |
101 | ) : Column(mask, index, timestamp, value_size, value), |
102 | ttl_(ttl) {} |
103 | |
104 | std::size_t ExpiringColumn::Size() const { |
105 | return Column::Size() + sizeof(ttl_); |
106 | } |
107 | |
108 | void ExpiringColumn::Serialize(std::string* dest) const { |
109 | Column::Serialize(dest); |
110 | rocksdb::cassandra::Serialize<int32_t>(ttl_, dest); |
111 | } |
112 | |
113 | std::chrono::time_point<std::chrono::system_clock> ExpiringColumn::TimePoint() const { |
114 | return std::chrono::time_point<std::chrono::system_clock>(std::chrono::microseconds(Timestamp())); |
115 | } |
116 | |
117 | std::chrono::seconds ExpiringColumn::Ttl() const { |
118 | return std::chrono::seconds(ttl_); |
119 | } |
120 | |
121 | bool ExpiringColumn::Expired() const { |
122 | return TimePoint() + Ttl() < std::chrono::system_clock::now(); |
123 | } |
124 | |
125 | std::shared_ptr<Tombstone> ExpiringColumn::ToTombstone() const { |
126 | auto expired_at = (TimePoint() + Ttl()).time_since_epoch(); |
127 | int32_t local_deletion_time = static_cast<int32_t>( |
128 | std::chrono::duration_cast<std::chrono::seconds>(expired_at).count()); |
129 | int64_t marked_for_delete_at = |
130 | std::chrono::duration_cast<std::chrono::microseconds>(expired_at).count(); |
131 | return std::make_shared<Tombstone>( |
132 | static_cast<int8_t>(ColumnTypeMask::DELETION_MASK), |
133 | Index(), |
134 | local_deletion_time, |
135 | marked_for_delete_at); |
136 | } |
137 | |
138 | std::shared_ptr<ExpiringColumn> ExpiringColumn::Deserialize( |
139 | const char *src, |
140 | std::size_t offset) { |
141 | int8_t mask = rocksdb::cassandra::Deserialize<int8_t>(src, offset); |
142 | offset += sizeof(mask); |
143 | int8_t index = rocksdb::cassandra::Deserialize<int8_t>(src, offset); |
144 | offset += sizeof(index); |
145 | int64_t timestamp = rocksdb::cassandra::Deserialize<int64_t>(src, offset); |
146 | offset += sizeof(timestamp); |
147 | int32_t value_size = rocksdb::cassandra::Deserialize<int32_t>(src, offset); |
148 | offset += sizeof(value_size); |
149 | const char* value = src + offset; |
150 | offset += value_size; |
151 | int32_t ttl = rocksdb::cassandra::Deserialize<int32_t>(src, offset); |
152 | return std::make_shared<ExpiringColumn>( |
153 | mask, index, timestamp, value_size, value, ttl); |
154 | } |
155 | |
156 | Tombstone::Tombstone( |
157 | int8_t mask, |
158 | int8_t index, |
159 | int32_t local_deletion_time, |
160 | int64_t marked_for_delete_at |
161 | ) : ColumnBase(mask, index), local_deletion_time_(local_deletion_time), |
162 | marked_for_delete_at_(marked_for_delete_at) {} |
163 | |
164 | int64_t Tombstone::Timestamp() const { |
165 | return marked_for_delete_at_; |
166 | } |
167 | |
168 | std::size_t Tombstone::Size() const { |
169 | return ColumnBase::Size() + sizeof(local_deletion_time_) |
170 | + sizeof(marked_for_delete_at_); |
171 | } |
172 | |
173 | void Tombstone::Serialize(std::string* dest) const { |
174 | ColumnBase::Serialize(dest); |
175 | rocksdb::cassandra::Serialize<int32_t>(local_deletion_time_, dest); |
176 | rocksdb::cassandra::Serialize<int64_t>(marked_for_delete_at_, dest); |
177 | } |
178 | |
179 | bool Tombstone::Collectable(int32_t gc_grace_period_in_seconds) const { |
180 | auto local_deleted_at = std::chrono::time_point<std::chrono::system_clock>( |
181 | std::chrono::seconds(local_deletion_time_)); |
182 | auto gc_grace_period = std::chrono::seconds(gc_grace_period_in_seconds); |
183 | return local_deleted_at + gc_grace_period < std::chrono::system_clock::now(); |
184 | } |
185 | |
186 | std::shared_ptr<Tombstone> Tombstone::Deserialize(const char *src, |
187 | std::size_t offset) { |
188 | int8_t mask = rocksdb::cassandra::Deserialize<int8_t>(src, offset); |
189 | offset += sizeof(mask); |
190 | int8_t index = rocksdb::cassandra::Deserialize<int8_t>(src, offset); |
191 | offset += sizeof(index); |
192 | int32_t local_deletion_time = |
193 | rocksdb::cassandra::Deserialize<int32_t>(src, offset); |
194 | offset += sizeof(int32_t); |
195 | int64_t marked_for_delete_at = |
196 | rocksdb::cassandra::Deserialize<int64_t>(src, offset); |
197 | return std::make_shared<Tombstone>( |
198 | mask, index, local_deletion_time, marked_for_delete_at); |
199 | } |
200 | |
201 | RowValue::RowValue(int32_t local_deletion_time, int64_t marked_for_delete_at) |
202 | : local_deletion_time_(local_deletion_time), |
203 | marked_for_delete_at_(marked_for_delete_at), columns_(), |
204 | last_modified_time_(0) {} |
205 | |
206 | RowValue::RowValue(Columns columns, |
207 | int64_t last_modified_time) |
208 | : local_deletion_time_(kDefaultLocalDeletionTime), |
209 | marked_for_delete_at_(kDefaultMarkedForDeleteAt), |
210 | columns_(std::move(columns)), last_modified_time_(last_modified_time) {} |
211 | |
212 | std::size_t RowValue::Size() const { |
213 | std::size_t size = sizeof(local_deletion_time_) |
214 | + sizeof(marked_for_delete_at_); |
215 | for (const auto& column : columns_) { |
216 | size += column -> Size(); |
217 | } |
218 | return size; |
219 | } |
220 | |
221 | int64_t RowValue::LastModifiedTime() const { |
222 | if (IsTombstone()) { |
223 | return marked_for_delete_at_; |
224 | } else { |
225 | return last_modified_time_; |
226 | } |
227 | } |
228 | |
229 | bool RowValue::IsTombstone() const { |
230 | return marked_for_delete_at_ > kDefaultMarkedForDeleteAt; |
231 | } |
232 | |
233 | void RowValue::Serialize(std::string* dest) const { |
234 | rocksdb::cassandra::Serialize<int32_t>(local_deletion_time_, dest); |
235 | rocksdb::cassandra::Serialize<int64_t>(marked_for_delete_at_, dest); |
236 | for (const auto& column : columns_) { |
237 | column -> Serialize(dest); |
238 | } |
239 | } |
240 | |
241 | RowValue RowValue::RemoveExpiredColumns(bool* changed) const { |
242 | *changed = false; |
243 | Columns new_columns; |
244 | for (auto& column : columns_) { |
245 | if(column->Mask() == ColumnTypeMask::EXPIRATION_MASK) { |
246 | std::shared_ptr<ExpiringColumn> expiring_column = |
247 | std::static_pointer_cast<ExpiringColumn>(column); |
248 | |
249 | if(expiring_column->Expired()){ |
250 | *changed = true; |
251 | continue; |
252 | } |
253 | } |
254 | |
255 | new_columns.push_back(column); |
256 | } |
257 | return RowValue(std::move(new_columns), last_modified_time_); |
258 | } |
259 | |
260 | RowValue RowValue::ConvertExpiredColumnsToTombstones(bool* changed) const { |
261 | *changed = false; |
262 | Columns new_columns; |
263 | for (auto& column : columns_) { |
264 | if(column->Mask() == ColumnTypeMask::EXPIRATION_MASK) { |
265 | std::shared_ptr<ExpiringColumn> expiring_column = |
266 | std::static_pointer_cast<ExpiringColumn>(column); |
267 | |
268 | if(expiring_column->Expired()) { |
269 | std::shared_ptr<Tombstone> tombstone = expiring_column->ToTombstone(); |
270 | new_columns.push_back(tombstone); |
271 | *changed = true; |
272 | continue; |
273 | } |
274 | } |
275 | new_columns.push_back(column); |
276 | } |
277 | return RowValue(std::move(new_columns), last_modified_time_); |
278 | } |
279 | |
280 | RowValue RowValue::RemoveTombstones(int32_t gc_grace_period) const { |
281 | Columns new_columns; |
282 | for (auto& column : columns_) { |
283 | if (column->Mask() == ColumnTypeMask::DELETION_MASK) { |
284 | std::shared_ptr<Tombstone> tombstone = |
285 | std::static_pointer_cast<Tombstone>(column); |
286 | |
287 | if (tombstone->Collectable(gc_grace_period)) { |
288 | continue; |
289 | } |
290 | } |
291 | |
292 | new_columns.push_back(column); |
293 | } |
294 | return RowValue(std::move(new_columns), last_modified_time_); |
295 | } |
296 | |
297 | bool RowValue::Empty() const { |
298 | return columns_.empty(); |
299 | } |
300 | |
301 | RowValue RowValue::Deserialize(const char *src, std::size_t size) { |
302 | std::size_t offset = 0; |
303 | assert(size >= sizeof(local_deletion_time_) + sizeof(marked_for_delete_at_))(static_cast<void> (0)); |
304 | int32_t local_deletion_time = |
305 | rocksdb::cassandra::Deserialize<int32_t>(src, offset); |
306 | offset += sizeof(int32_t); |
307 | int64_t marked_for_delete_at = |
308 | rocksdb::cassandra::Deserialize<int64_t>(src, offset); |
309 | offset += sizeof(int64_t); |
310 | if (offset == size) { |
311 | return RowValue(local_deletion_time, marked_for_delete_at); |
312 | } |
313 | |
314 | assert(local_deletion_time == kDefaultLocalDeletionTime)(static_cast<void> (0)); |
315 | assert(marked_for_delete_at == kDefaultMarkedForDeleteAt)(static_cast<void> (0)); |
316 | Columns columns; |
317 | int64_t last_modified_time = 0; |
318 | while (offset < size) { |
319 | auto c = ColumnBase::Deserialize(src, offset); |
320 | offset += c -> Size(); |
321 | assert(offset <= size)(static_cast<void> (0)); |
322 | last_modified_time = std::max(last_modified_time, c -> Timestamp()); |
323 | columns.push_back(std::move(c)); |
324 | } |
325 | |
326 | return RowValue(std::move(columns), last_modified_time); |
327 | } |
328 | |
329 | |
330 | |
331 | |
332 | |
333 | |
334 | RowValue RowValue::Merge(std::vector<RowValue>&& values) { |
335 | assert(values.size() > 0)(static_cast<void> (0)); |
336 | if (values.size() == 1) { |
| 1 | Assuming the condition is false | |
|
| |
337 | return std::move(values[0]); |
338 | } |
339 | |
340 | |
341 | |
342 | std::sort(values.begin(), values.end(), |
343 | [](const RowValue& r1, const RowValue& r2) { |
344 | return r1.LastModifiedTime() > r2.LastModifiedTime(); |
345 | }); |
346 | |
347 | std::map<int8_t, std::shared_ptr<ColumnBase>> merged_columns; |
348 | int64_t tombstone_timestamp = 0; |
349 | |
350 | for (auto& value : values) { |
351 | if (value.IsTombstone()) { |
| |
| |
| |
352 | if (merged_columns.size() == 0) { |
353 | return std::move(value); |
354 | } |
355 | tombstone_timestamp = value.LastModifiedTime(); |
356 | break; |
357 | } |
358 | for (auto& column : value.columns_) { |
359 | int8_t index = column->Index(); |
360 | if (merged_columns.find(index) == merged_columns.end()) { |
| 6 | | Assuming the condition is true | |
|
| |
| 28 | | Assuming the condition is true | |
|
| |
361 | merged_columns[index] = column; |
| 8 | | Calling defaulted copy assignment operator for 'shared_ptr' | |
|
| 27 | | Returning; memory was released | |
|
| 30 | | Calling defaulted copy assignment operator for 'shared_ptr' | |
|
362 | } else { |
363 | if (column->Timestamp() > merged_columns[index]->Timestamp()) { |
364 | merged_columns[index] = column; |
365 | } |
366 | } |
367 | } |
368 | } |
369 | |
370 | int64_t last_modified_time = 0; |
371 | Columns columns; |
372 | for (auto& pair: merged_columns) { |
373 | |
374 | |
375 | |
376 | if (pair.second->Timestamp() <= tombstone_timestamp) { |
377 | continue; |
378 | } |
379 | last_modified_time = std::max(last_modified_time, pair.second->Timestamp()); |
380 | columns.push_back(std::move(pair.second)); |
381 | } |
382 | return RowValue(std::move(columns), last_modified_time); |
383 | } |
384 | |
385 | } |
386 | } |
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 | #ifndef _SHARED_PTR_H1 |
50 | #define _SHARED_PTR_H1 1 |
51 | |
52 | #include <bits/shared_ptr_base.h> |
53 | |
54 | namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default"))) |
55 | { |
56 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
57 | |
58 | |
59 | |
60 | |
61 | |
62 | |
63 | |
64 | template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp> |
65 | inline std::basic_ostream<_Ch, _Tr>& |
66 | operator<<(std::basic_ostream<_Ch, _Tr>& __os, |
67 | const __shared_ptr<_Tp, _Lp>& __p) |
68 | { |
69 | __os << __p.get(); |
70 | return __os; |
71 | } |
72 | |
73 | template<typename _Del, typename _Tp, _Lock_policy _Lp> |
74 | inline _Del* |
75 | get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept |
76 | { |
77 | #if __cpp_rtti199711 |
78 | return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); |
79 | #else |
80 | return 0; |
81 | #endif |
82 | } |
83 | |
84 | |
85 | template<typename _Del, typename _Tp> |
86 | inline _Del* |
87 | get_deleter(const shared_ptr<_Tp>& __p) noexcept |
88 | { |
89 | #if __cpp_rtti199711 |
90 | return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); |
91 | #else |
92 | return 0; |
93 | #endif |
94 | } |
95 | |
96 | |
97 | |
98 | |
99 | |
100 | |
101 | |
102 | template<typename _Tp> |
103 | class shared_ptr : public __shared_ptr<_Tp> |
104 | { |
105 | template<typename... _Args> |
106 | using _Constructible = typename enable_if< |
107 | is_constructible<__shared_ptr<_Tp>, _Args...>::value |
108 | >::type; |
109 | |
110 | template<typename _Arg> |
111 | using _Assignable = typename enable_if< |
112 | is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& |
113 | >::type; |
114 | |
115 | public: |
116 | |
117 | using element_type = typename __shared_ptr<_Tp>::element_type; |
118 | |
119 | #if __cplusplus201103L > 201402L |
120 | # define __cpp_lib_shared_ptr_weak_type 201606 |
121 | using weak_type = weak_ptr<_Tp>; |
122 | #endif |
123 | |
124 | |
125 | |
126 | |
127 | constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } |
128 | |
129 | shared_ptr(const shared_ptr&) noexcept = default; |
130 | |
131 | |
132 | |
133 | |
134 | |
135 | |
136 | |
137 | template<typename _Yp, typename = _Constructible<_Yp*>> |
138 | explicit |
139 | shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } |
140 | |
141 | |
142 | |
143 | |
144 | |
145 | |
146 | |
147 | |
148 | |
149 | |
150 | |
151 | |
152 | |
153 | |
154 | template<typename _Yp, typename _Deleter, |
155 | typename = _Constructible<_Yp*, _Deleter>> |
156 | shared_ptr(_Yp* __p, _Deleter __d) |
157 | : __shared_ptr<_Tp>(__p, std::move(__d)) { } |
158 | |
159 | |
160 | |
161 | |
162 | |
163 | |
164 | |
165 | |
166 | |
167 | |
168 | |
169 | |
170 | |
171 | |
172 | template<typename _Deleter> |
173 | shared_ptr(nullptr_t __p, _Deleter __d) |
174 | : __shared_ptr<_Tp>(__p, std::move(__d)) { } |
175 | |
176 | |
177 | |
178 | |
179 | |
180 | |
181 | |
182 | |
183 | |
184 | |
185 | |
186 | |
187 | |
188 | |
189 | |
190 | |
191 | template<typename _Yp, typename _Deleter, typename _Alloc, |
192 | typename = _Constructible<_Yp*, _Deleter, _Alloc>> |
193 | shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) |
194 | : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } |
195 | |
196 | |
197 | |
198 | |
199 | |
200 | |
201 | |
202 | |
203 | |
204 | |
205 | |
206 | |
207 | |
208 | |
209 | |
210 | |
211 | template<typename _Deleter, typename _Alloc> |
212 | shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) |
213 | : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } |
214 | |
215 | |
216 | |
217 | |
218 | |
219 | |
220 | |
221 | |
222 | |
223 | |
224 | |
225 | |
226 | |
227 | |
228 | |
229 | |
230 | |
231 | |
232 | |
233 | template<typename _Yp> |
234 | shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept |
235 | : __shared_ptr<_Tp>(__r, __p) { } |
236 | |
237 | |
238 | |
239 | |
240 | |
241 | |
242 | |
243 | |
244 | template<typename _Yp, |
245 | typename = _Constructible<const shared_ptr<_Yp>&>> |
246 | shared_ptr(const shared_ptr<_Yp>& __r) noexcept |
247 | : __shared_ptr<_Tp>(__r) { } |
248 | |
249 | |
250 | |
251 | |
252 | |
253 | |
254 | shared_ptr(shared_ptr&& __r) noexcept |
255 | : __shared_ptr<_Tp>(std::move(__r)) { } |
256 | |
257 | |
258 | |
259 | |
260 | |
261 | |
262 | template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>> |
263 | shared_ptr(shared_ptr<_Yp>&& __r) noexcept |
264 | : __shared_ptr<_Tp>(std::move(__r)) { } |
265 | |
266 | |
267 | |
268 | |
269 | |
270 | |
271 | |
272 | |
273 | |
274 | template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>> |
275 | explicit shared_ptr(const weak_ptr<_Yp>& __r) |
276 | : __shared_ptr<_Tp>(__r) { } |
277 | |
278 | #if _GLIBCXX_USE_DEPRECATED1 |
279 | #pragma GCC diagnostic push |
280 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
281 | template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>> |
282 | shared_ptr(auto_ptr<_Yp>&& __r); |
283 | #pragma GCC diagnostic pop |
284 | #endif |
285 | |
286 | |
287 | |
288 | template<typename _Yp, typename _Del, |
289 | typename = _Constructible<unique_ptr<_Yp, _Del>>> |
290 | shared_ptr(unique_ptr<_Yp, _Del>&& __r) |
291 | : __shared_ptr<_Tp>(std::move(__r)) { } |
292 | |
293 | #if __cplusplus201103L <= 201402L && _GLIBCXX_USE_DEPRECATED1 |
294 | |
295 | |
296 | |
297 | template<typename _Yp, typename _Del, |
298 | _Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0> |
299 | shared_ptr(unique_ptr<_Yp, _Del>&& __r) |
300 | : __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { } |
301 | #endif |
302 | |
303 | |
304 | |
305 | |
306 | |
307 | constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } |
308 | |
309 | shared_ptr& operator=(const shared_ptr&) noexcept = default; |
| 9 | | Calling defaulted copy assignment operator for '__shared_ptr' | |
|
| 26 | | Returning; memory was released | |
|
| 31 | | Calling defaulted copy assignment operator for '__shared_ptr' | |
|
310 | |
311 | template<typename _Yp> |
312 | _Assignable<const shared_ptr<_Yp>&> |
313 | operator=(const shared_ptr<_Yp>& __r) noexcept |
314 | { |
315 | this->__shared_ptr<_Tp>::operator=(__r); |
316 | return *this; |
317 | } |
318 | |
319 | #if _GLIBCXX_USE_DEPRECATED1 |
320 | #pragma GCC diagnostic push |
321 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
322 | template<typename _Yp> |
323 | _Assignable<auto_ptr<_Yp>> |
324 | operator=(auto_ptr<_Yp>&& __r) |
325 | { |
326 | this->__shared_ptr<_Tp>::operator=(std::move(__r)); |
327 | return *this; |
328 | } |
329 | #pragma GCC diagnostic pop |
330 | #endif |
331 | |
332 | shared_ptr& |
333 | operator=(shared_ptr&& __r) noexcept |
334 | { |
335 | this->__shared_ptr<_Tp>::operator=(std::move(__r)); |
336 | return *this; |
337 | } |
338 | |
339 | template<class _Yp> |
340 | _Assignable<shared_ptr<_Yp>> |
341 | operator=(shared_ptr<_Yp>&& __r) noexcept |
342 | { |
343 | this->__shared_ptr<_Tp>::operator=(std::move(__r)); |
344 | return *this; |
345 | } |
346 | |
347 | template<typename _Yp, typename _Del> |
348 | _Assignable<unique_ptr<_Yp, _Del>> |
349 | operator=(unique_ptr<_Yp, _Del>&& __r) |
350 | { |
351 | this->__shared_ptr<_Tp>::operator=(std::move(__r)); |
352 | return *this; |
353 | } |
354 | |
355 | private: |
356 | |
357 | template<typename _Alloc, typename... _Args> |
358 | shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) |
359 | : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...) |
360 | { } |
361 | |
362 | template<typename _Yp, typename _Alloc, typename... _Args> |
363 | friend shared_ptr<_Yp> |
364 | allocate_shared(const _Alloc& __a, _Args&&... __args); |
365 | |
366 | |
367 | shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) |
368 | : __shared_ptr<_Tp>(__r, std::nothrow) { } |
369 | |
370 | friend class weak_ptr<_Tp>; |
371 | }; |
372 | |
373 | #if __cpp_deduction_guides >= 201606 |
374 | template<typename _Tp> |
375 | shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; |
376 | template<typename _Tp, typename _Del> |
377 | shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>; |
378 | #endif |
379 | |
380 | |
381 | template<typename _Tp, typename _Up> |
382 | inline bool |
383 | operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept |
384 | { return __a.get() == __b.get(); } |
385 | |
386 | template<typename _Tp> |
387 | inline bool |
388 | operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept |
389 | { return !__a; } |
390 | |
391 | template<typename _Tp> |
392 | inline bool |
393 | operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept |
394 | { return !__a; } |
395 | |
396 | template<typename _Tp, typename _Up> |
397 | inline bool |
398 | operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept |
399 | { return __a.get() != __b.get(); } |
400 | |
401 | template<typename _Tp> |
402 | inline bool |
403 | operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept |
404 | { return (bool)__a; } |
405 | |
406 | template<typename _Tp> |
407 | inline bool |
408 | operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept |
409 | { return (bool)__a; } |
410 | |
411 | template<typename _Tp, typename _Up> |
412 | inline bool |
413 | operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept |
414 | { |
415 | using _Tp_elt = typename shared_ptr<_Tp>::element_type; |
416 | using _Up_elt = typename shared_ptr<_Up>::element_type; |
417 | using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; |
418 | return less<_Vp>()(__a.get(), __b.get()); |
419 | } |
420 | |
421 | template<typename _Tp> |
422 | inline bool |
423 | operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept |
424 | { |
425 | using _Tp_elt = typename shared_ptr<_Tp>::element_type; |
426 | return less<_Tp_elt*>()(__a.get(), nullptr); |
427 | } |
428 | |
429 | template<typename _Tp> |
430 | inline bool |
431 | operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept |
432 | { |
433 | using _Tp_elt = typename shared_ptr<_Tp>::element_type; |
434 | return less<_Tp_elt*>()(nullptr, __a.get()); |
435 | } |
436 | |
437 | template<typename _Tp, typename _Up> |
438 | inline bool |
439 | operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept |
440 | { return !(__b < __a); } |
441 | |
442 | template<typename _Tp> |
443 | inline bool |
444 | operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept |
445 | { return !(nullptr < __a); } |
446 | |
447 | template<typename _Tp> |
448 | inline bool |
449 | operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept |
450 | { return !(__a < nullptr); } |
451 | |
452 | template<typename _Tp, typename _Up> |
453 | inline bool |
454 | operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept |
455 | { return (__b < __a); } |
456 | |
457 | template<typename _Tp> |
458 | inline bool |
459 | operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept |
460 | { return nullptr < __a; } |
461 | |
462 | template<typename _Tp> |
463 | inline bool |
464 | operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept |
465 | { return __a < nullptr; } |
466 | |
467 | template<typename _Tp, typename _Up> |
468 | inline bool |
469 | operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept |
470 | { return !(__a < __b); } |
471 | |
472 | template<typename _Tp> |
473 | inline bool |
474 | operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept |
475 | { return !(__a < nullptr); } |
476 | |
477 | template<typename _Tp> |
478 | inline bool |
479 | operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept |
480 | { return !(nullptr < __a); } |
481 | |
482 | template<typename _Tp> |
483 | struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>> |
484 | { }; |
485 | |
486 | |
487 | template<typename _Tp> |
488 | inline void |
489 | swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept |
490 | { __a.swap(__b); } |
491 | |
492 | |
493 | template<typename _Tp, typename _Up> |
494 | inline shared_ptr<_Tp> |
495 | static_pointer_cast(const shared_ptr<_Up>& __r) noexcept |
496 | { |
497 | using _Sp = shared_ptr<_Tp>; |
498 | return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get())); |
499 | } |
500 | |
501 | template<typename _Tp, typename _Up> |
502 | inline shared_ptr<_Tp> |
503 | const_pointer_cast(const shared_ptr<_Up>& __r) noexcept |
504 | { |
505 | using _Sp = shared_ptr<_Tp>; |
506 | return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get())); |
507 | } |
508 | |
509 | template<typename _Tp, typename _Up> |
510 | inline shared_ptr<_Tp> |
511 | dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept |
512 | { |
513 | using _Sp = shared_ptr<_Tp>; |
514 | if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get())) |
515 | return _Sp(__r, __p); |
516 | return _Sp(); |
517 | } |
518 | |
519 | #if __cplusplus201103L > 201402L |
520 | template<typename _Tp, typename _Up> |
521 | inline shared_ptr<_Tp> |
522 | reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept |
523 | { |
524 | using _Sp = shared_ptr<_Tp>; |
525 | return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get())); |
526 | } |
527 | #endif |
528 | |
529 | |
530 | |
531 | |
532 | |
533 | |
534 | template<typename _Tp> |
535 | class weak_ptr : public __weak_ptr<_Tp> |
536 | { |
537 | template<typename _Arg> |
538 | using _Constructible = typename enable_if< |
539 | is_constructible<__weak_ptr<_Tp>, _Arg>::value |
540 | >::type; |
541 | |
542 | template<typename _Arg> |
543 | using _Assignable = typename enable_if< |
544 | is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& |
545 | >::type; |
546 | |
547 | public: |
548 | constexpr weak_ptr() noexcept = default; |
549 | |
550 | template<typename _Yp, |
551 | typename = _Constructible<const shared_ptr<_Yp>&>> |
552 | weak_ptr(const shared_ptr<_Yp>& __r) noexcept |
553 | : __weak_ptr<_Tp>(__r) { } |
554 | |
555 | weak_ptr(const weak_ptr&) noexcept = default; |
556 | |
557 | template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>> |
558 | weak_ptr(const weak_ptr<_Yp>& __r) noexcept |
559 | : __weak_ptr<_Tp>(__r) { } |
560 | |
561 | weak_ptr(weak_ptr&&) noexcept = default; |
562 | |
563 | template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>> |
564 | weak_ptr(weak_ptr<_Yp>&& __r) noexcept |
565 | : __weak_ptr<_Tp>(std::move(__r)) { } |
566 | |
567 | weak_ptr& |
568 | operator=(const weak_ptr& __r) noexcept = default; |
569 | |
570 | template<typename _Yp> |
571 | _Assignable<const weak_ptr<_Yp>&> |
572 | operator=(const weak_ptr<_Yp>& __r) noexcept |
573 | { |
574 | this->__weak_ptr<_Tp>::operator=(__r); |
575 | return *this; |
576 | } |
577 | |
578 | template<typename _Yp> |
579 | _Assignable<const shared_ptr<_Yp>&> |
580 | operator=(const shared_ptr<_Yp>& __r) noexcept |
581 | { |
582 | this->__weak_ptr<_Tp>::operator=(__r); |
583 | return *this; |
584 | } |
585 | |
586 | weak_ptr& |
587 | operator=(weak_ptr&& __r) noexcept = default; |
588 | |
589 | template<typename _Yp> |
590 | _Assignable<weak_ptr<_Yp>> |
591 | operator=(weak_ptr<_Yp>&& __r) noexcept |
592 | { |
593 | this->__weak_ptr<_Tp>::operator=(std::move(__r)); |
594 | return *this; |
595 | } |
596 | |
597 | shared_ptr<_Tp> |
598 | lock() const noexcept |
599 | { return shared_ptr<_Tp>(*this, std::nothrow); } |
600 | }; |
601 | |
602 | #if __cpp_deduction_guides >= 201606 |
603 | template<typename _Tp> |
604 | weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; |
605 | #endif |
606 | |
607 | |
608 | template<typename _Tp> |
609 | inline void |
610 | swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept |
611 | { __a.swap(__b); } |
612 | |
613 | |
614 | |
615 | template<typename _Tp = void> |
616 | struct owner_less; |
617 | |
618 | |
619 | template<> |
620 | struct owner_less<void> : _Sp_owner_less<void, void> |
621 | { }; |
622 | |
623 | |
624 | template<typename _Tp> |
625 | struct owner_less<shared_ptr<_Tp>> |
626 | : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>> |
627 | { }; |
628 | |
629 | |
630 | template<typename _Tp> |
631 | struct owner_less<weak_ptr<_Tp>> |
632 | : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>> |
633 | { }; |
634 | |
635 | |
636 | |
637 | |
638 | template<typename _Tp> |
639 | class enable_shared_from_this |
640 | { |
641 | protected: |
642 | constexpr enable_shared_from_this() noexcept { } |
643 | |
644 | enable_shared_from_this(const enable_shared_from_this&) noexcept { } |
645 | |
646 | enable_shared_from_this& |
647 | operator=(const enable_shared_from_this&) noexcept |
648 | { return *this; } |
649 | |
650 | ~enable_shared_from_this() { } |
651 | |
652 | public: |
653 | shared_ptr<_Tp> |
654 | shared_from_this() |
655 | { return shared_ptr<_Tp>(this->_M_weak_this); } |
656 | |
657 | shared_ptr<const _Tp> |
658 | shared_from_this() const |
659 | { return shared_ptr<const _Tp>(this->_M_weak_this); } |
660 | |
661 | #if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11 |
662 | #define __cpp_lib_enable_shared_from_this 201603 |
663 | weak_ptr<_Tp> |
664 | weak_from_this() noexcept |
665 | { return this->_M_weak_this; } |
666 | |
667 | weak_ptr<const _Tp> |
668 | weak_from_this() const noexcept |
669 | { return this->_M_weak_this; } |
670 | #endif |
671 | |
672 | private: |
673 | template<typename _Tp1> |
674 | void |
675 | _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept |
676 | { _M_weak_this._M_assign(__p, __n); } |
677 | |
678 | |
679 | friend const enable_shared_from_this* |
680 | __enable_shared_from_this_base(const __shared_count<>&, |
681 | const enable_shared_from_this* __p) |
682 | { return __p; } |
683 | |
684 | template<typename, _Lock_policy> |
685 | friend class __shared_ptr; |
686 | |
687 | mutable weak_ptr<_Tp> _M_weak_this; |
688 | }; |
689 | |
690 | |
691 | |
692 | |
693 | |
694 | |
695 | |
696 | |
697 | |
698 | |
699 | |
700 | |
701 | template<typename _Tp, typename _Alloc, typename... _Args> |
702 | inline shared_ptr<_Tp> |
703 | allocate_shared(const _Alloc& __a, _Args&&... __args) |
704 | { |
705 | return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, |
706 | std::forward<_Args>(__args)...); |
707 | } |
708 | |
709 | |
710 | |
711 | |
712 | |
713 | |
714 | |
715 | |
716 | template<typename _Tp, typename... _Args> |
717 | inline shared_ptr<_Tp> |
718 | make_shared(_Args&&... __args) |
719 | { |
720 | typedef typename std::remove_cv<_Tp>::type _Tp_nc; |
721 | return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(), |
722 | std::forward<_Args>(__args)...); |
723 | } |
724 | |
725 | |
726 | template<typename _Tp> |
727 | struct hash<shared_ptr<_Tp>> |
728 | : public __hash_base<size_t, shared_ptr<_Tp>> |
729 | { |
730 | size_t |
731 | operator()(const shared_ptr<_Tp>& __s) const noexcept |
732 | { |
733 | return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get()); |
734 | } |
735 | }; |
736 | |
737 | |
738 | |
739 | _GLIBCXX_END_NAMESPACE_VERSION |
740 | } |
741 | |
742 | #endif // _SHARED_PTR_H |
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 | #ifndef _SHARED_PTR_BASE_H1 |
50 | #define _SHARED_PTR_BASE_H1 1 |
51 | |
52 | #include <typeinfo> |
53 | #include <bits/allocated_ptr.h> |
54 | #include <bits/refwrap.h> |
55 | #include <bits/stl_function.h> |
56 | #include <ext/aligned_buffer.h> |
57 | |
58 | namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default"))) |
59 | { |
60 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
61 | |
62 | #if _GLIBCXX_USE_DEPRECATED1 |
63 | #pragma GCC diagnostic push |
64 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
65 | template<typename> class auto_ptr; |
66 | #pragma GCC diagnostic pop |
67 | #endif |
68 | |
69 | |
70 | |
71 | |
72 | |
73 | class bad_weak_ptr : public std::exception |
74 | { |
75 | public: |
76 | virtual char const* what() const noexcept; |
77 | |
78 | virtual ~bad_weak_ptr() noexcept; |
79 | }; |
80 | |
81 | |
82 | inline void |
83 | __throw_bad_weak_ptr() |
84 | { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr())(throw (bad_weak_ptr())); } |
85 | |
86 | using __gnu_cxx::_Lock_policy; |
87 | using __gnu_cxx::__default_lock_policy; |
88 | using __gnu_cxx::_S_single; |
89 | using __gnu_cxx::_S_mutex; |
90 | using __gnu_cxx::_S_atomic; |
91 | |
92 | |
93 | template<_Lock_policy _Lp> |
94 | class _Mutex_base |
95 | { |
96 | protected: |
97 | |
98 | enum { _S_need_barriers = 0 }; |
99 | }; |
100 | |
101 | template<> |
102 | class _Mutex_base<_S_mutex> |
103 | : public __gnu_cxx::__mutex |
104 | { |
105 | protected: |
106 | |
107 | |
108 | |
109 | enum { _S_need_barriers = 1 }; |
110 | }; |
111 | |
112 | template<_Lock_policy _Lp = __default_lock_policy> |
113 | class _Sp_counted_base |
114 | : public _Mutex_base<_Lp> |
115 | { |
116 | public: |
117 | _Sp_counted_base() noexcept |
118 | : _M_use_count(1), _M_weak_count(1) { } |
119 | |
120 | virtual |
121 | ~_Sp_counted_base() noexcept |
122 | { } |
123 | |
124 | |
125 | |
126 | virtual void |
127 | _M_dispose() noexcept = 0; |
128 | |
129 | |
130 | virtual void |
131 | _M_destroy() noexcept |
132 | { delete this; } |
| |
133 | |
134 | virtual void* |
135 | _M_get_deleter(const std::type_info&) noexcept = 0; |
136 | |
137 | void |
138 | _M_add_ref_copy() |
139 | { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } |
140 | |
141 | void |
142 | _M_add_ref_lock(); |
143 | |
144 | bool |
145 | _M_add_ref_lock_nothrow(); |
146 | |
147 | void |
148 | _M_release() noexcept |
149 | { |
150 | |
151 | _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count); |
152 | if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) |
| 16 | | Assuming the condition is true | |
|
| |
| 38 | | Calling '__exchange_and_add_dispatch' | |
|
153 | { |
154 | _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count); |
155 | _M_dispose(); |
156 | |
157 | |
158 | |
159 | |
160 | if (_Mutex_base<_Lp>::_S_need_barriers) |
| |
161 | { |
162 | __atomic_thread_fence (__ATOMIC_ACQ_REL4); |
163 | } |
164 | |
165 | |
166 | _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); |
167 | if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, |
| 19 | | Assuming the condition is true | |
|
| |
168 | -1) == 1) |
169 | { |
170 | _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); |
171 | _M_destroy(); |
| 21 | | Calling '_Sp_counted_base::_M_destroy' | |
|
| 23 | | Returning; memory was released | |
|
172 | } |
173 | } |
174 | } |
175 | |
176 | void |
177 | _M_weak_add_ref() noexcept |
178 | { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } |
179 | |
180 | void |
181 | _M_weak_release() noexcept |
182 | { |
183 | |
184 | _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); |
185 | if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) |
186 | { |
187 | _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); |
188 | if (_Mutex_base<_Lp>::_S_need_barriers) |
189 | { |
190 | |
191 | |
192 | __atomic_thread_fence (__ATOMIC_ACQ_REL4); |
193 | } |
194 | _M_destroy(); |
195 | } |
196 | } |
197 | |
198 | long |
199 | _M_get_use_count() const noexcept |
200 | { |
201 | |
202 | |
203 | return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED0); |
204 | } |
205 | |
206 | private: |
207 | _Sp_counted_base(_Sp_counted_base const&) = delete; |
208 | _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; |
209 | |
210 | _Atomic_word _M_use_count; |
211 | _Atomic_word _M_weak_count; |
212 | }; |
213 | |
214 | template<> |
215 | inline void |
216 | _Sp_counted_base<_S_single>:: |
217 | _M_add_ref_lock() |
218 | { |
219 | if (_M_use_count == 0) |
220 | __throw_bad_weak_ptr(); |
221 | ++_M_use_count; |
222 | } |
223 | |
224 | template<> |
225 | inline void |
226 | _Sp_counted_base<_S_mutex>:: |
227 | _M_add_ref_lock() |
228 | { |
229 | __gnu_cxx::__scoped_lock sentry(*this); |
230 | if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) |
231 | { |
232 | _M_use_count = 0; |
233 | __throw_bad_weak_ptr(); |
234 | } |
235 | } |
236 | |
237 | template<> |
238 | inline void |
239 | _Sp_counted_base<_S_atomic>:: |
240 | _M_add_ref_lock() |
241 | { |
242 | |
243 | _Atomic_word __count = _M_get_use_count(); |
244 | do |
245 | { |
246 | if (__count == 0) |
247 | __throw_bad_weak_ptr(); |
248 | |
249 | |
250 | } |
251 | while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, |
252 | true, __ATOMIC_ACQ_REL4, |
253 | __ATOMIC_RELAXED0)); |
254 | } |
255 | |
256 | template<> |
257 | inline bool |
258 | _Sp_counted_base<_S_single>:: |
259 | _M_add_ref_lock_nothrow() |
260 | { |
261 | if (_M_use_count == 0) |
262 | return false; |
263 | ++_M_use_count; |
264 | return true; |
265 | } |
266 | |
267 | template<> |
268 | inline bool |
269 | _Sp_counted_base<_S_mutex>:: |
270 | _M_add_ref_lock_nothrow() |
271 | { |
272 | __gnu_cxx::__scoped_lock sentry(*this); |
273 | if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) |
274 | { |
275 | _M_use_count = 0; |
276 | return false; |
277 | } |
278 | return true; |
279 | } |
280 | |
281 | template<> |
282 | inline bool |
283 | _Sp_counted_base<_S_atomic>:: |
284 | _M_add_ref_lock_nothrow() |
285 | { |
286 | |
287 | _Atomic_word __count = _M_get_use_count(); |
288 | do |
289 | { |
290 | if (__count == 0) |
291 | return false; |
292 | |
293 | |
294 | } |
295 | while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, |
296 | true, __ATOMIC_ACQ_REL4, |
297 | __ATOMIC_RELAXED0)); |
298 | return true; |
299 | } |
300 | |
301 | template<> |
302 | inline void |
303 | _Sp_counted_base<_S_single>::_M_add_ref_copy() |
304 | { ++_M_use_count; } |
305 | |
306 | template<> |
307 | inline void |
308 | _Sp_counted_base<_S_single>::_M_release() noexcept |
309 | { |
310 | if (--_M_use_count == 0) |
311 | { |
312 | _M_dispose(); |
313 | if (--_M_weak_count == 0) |
314 | _M_destroy(); |
315 | } |
316 | } |
317 | |
318 | template<> |
319 | inline void |
320 | _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept |
321 | { ++_M_weak_count; } |
322 | |
323 | template<> |
324 | inline void |
325 | _Sp_counted_base<_S_single>::_M_weak_release() noexcept |
326 | { |
327 | if (--_M_weak_count == 0) |
328 | _M_destroy(); |
329 | } |
330 | |
331 | template<> |
332 | inline long |
333 | _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept |
334 | { return _M_use_count; } |
335 | |
336 | |
337 | |
338 | template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> |
339 | class __shared_ptr; |
340 | |
341 | template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> |
342 | class __weak_ptr; |
343 | |
344 | template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> |
345 | class __enable_shared_from_this; |
346 | |
347 | template<typename _Tp> |
348 | class shared_ptr; |
349 | |
350 | template<typename _Tp> |
351 | class weak_ptr; |
352 | |
353 | template<typename _Tp> |
354 | struct owner_less; |
355 | |
356 | template<typename _Tp> |
357 | class enable_shared_from_this; |
358 | |
359 | template<_Lock_policy _Lp = __default_lock_policy> |
360 | class __weak_count; |
361 | |
362 | template<_Lock_policy _Lp = __default_lock_policy> |
363 | class __shared_count; |
364 | |
365 | |
366 | |
367 | template<typename _Ptr, _Lock_policy _Lp> |
368 | class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> |
369 | { |
370 | public: |
371 | explicit |
372 | _Sp_counted_ptr(_Ptr __p) noexcept |
373 | : _M_ptr(__p) { } |
374 | |
375 | virtual void |
376 | _M_dispose() noexcept |
377 | { delete _M_ptr; } |
378 | |
379 | virtual void |
380 | _M_destroy() noexcept |
381 | { delete this; } |
382 | |
383 | virtual void* |
384 | _M_get_deleter(const std::type_info&) noexcept |
385 | { return nullptr; } |
386 | |
387 | _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; |
388 | _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; |
389 | |
390 | private: |
391 | _Ptr _M_ptr; |
392 | }; |
393 | |
394 | template<> |
395 | inline void |
396 | _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { } |
397 | |
398 | template<> |
399 | inline void |
400 | _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { } |
401 | |
402 | template<> |
403 | inline void |
404 | _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { } |
405 | |
406 | template<int _Nm, typename _Tp, |
407 | bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)> |
408 | struct _Sp_ebo_helper; |
409 | |
410 | |
411 | template<int _Nm, typename _Tp> |
412 | struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp |
413 | { |
414 | explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } |
415 | explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { } |
416 | |
417 | static _Tp& |
418 | _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } |
419 | }; |
420 | |
421 | |
422 | template<int _Nm, typename _Tp> |
423 | struct _Sp_ebo_helper<_Nm, _Tp, false> |
424 | { |
425 | explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } |
426 | explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { } |
427 | |
428 | static _Tp& |
429 | _S_get(_Sp_ebo_helper& __eboh) |
430 | { return __eboh._M_tp; } |
431 | |
432 | private: |
433 | _Tp _M_tp; |
434 | }; |
435 | |
436 | |
437 | template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp> |
438 | class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> |
439 | { |
440 | class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> |
441 | { |
442 | typedef _Sp_ebo_helper<0, _Deleter> _Del_base; |
443 | typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; |
444 | |
445 | public: |
446 | _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept |
447 | : _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a) |
448 | { } |
449 | |
450 | _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } |
451 | _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } |
452 | |
453 | _Ptr _M_ptr; |
454 | }; |
455 | |
456 | public: |
457 | using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>; |
458 | |
459 | |
460 | _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept |
461 | : _M_impl(__p, std::move(__d), _Alloc()) { } |
462 | |
463 | |
464 | _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept |
465 | : _M_impl(__p, std::move(__d), __a) { } |
466 | |
467 | ~_Sp_counted_deleter() noexcept { } |
468 | |
469 | virtual void |
470 | _M_dispose() noexcept |
471 | { _M_impl._M_del()(_M_impl._M_ptr); } |
472 | |
473 | virtual void |
474 | _M_destroy() noexcept |
475 | { |
476 | __allocator_type __a(_M_impl._M_alloc()); |
477 | __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; |
478 | this->~_Sp_counted_deleter(); |
479 | } |
480 | |
481 | virtual void* |
482 | _M_get_deleter(const std::type_info& __ti) noexcept |
483 | { |
484 | #if __cpp_rtti199711 |
485 | |
486 | |
487 | return __ti == typeid(_Deleter) |
488 | ? std::__addressof(_M_impl._M_del()) |
489 | : nullptr; |
490 | #else |
491 | return nullptr; |
492 | #endif |
493 | } |
494 | |
495 | private: |
496 | _Impl _M_impl; |
497 | }; |
498 | |
499 | |
500 | |
501 | struct _Sp_make_shared_tag |
502 | { |
503 | private: |
504 | template<typename _Tp, typename _Alloc, _Lock_policy _Lp> |
505 | friend class _Sp_counted_ptr_inplace; |
506 | |
507 | static const type_info& |
508 | _S_ti() noexcept _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default"))) |
509 | { |
510 | alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { }; |
511 | return reinterpret_cast<const type_info&>(__tag); |
512 | } |
513 | }; |
514 | |
515 | template<typename _Alloc> |
516 | struct _Sp_alloc_shared_tag |
517 | { |
518 | const _Alloc& _M_a; |
519 | }; |
520 | |
521 | template<typename _Tp, typename _Alloc, _Lock_policy _Lp> |
522 | class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> |
523 | { |
524 | class _Impl : _Sp_ebo_helper<0, _Alloc> |
525 | { |
526 | typedef _Sp_ebo_helper<0, _Alloc> _A_base; |
527 | |
528 | public: |
529 | explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } |
530 | |
531 | _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } |
532 | |
533 | __gnu_cxx::__aligned_buffer<_Tp> _M_storage; |
534 | }; |
535 | |
536 | public: |
537 | using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>; |
538 | |
539 | template<typename... _Args> |
540 | _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) |
541 | : _M_impl(__a) |
542 | { |
543 | |
544 | |
545 | allocator_traits<_Alloc>::construct(__a, _M_ptr(), |
546 | std::forward<_Args>(__args)...); |
547 | } |
548 | |
549 | ~_Sp_counted_ptr_inplace() noexcept { } |
550 | |
551 | virtual void |
552 | _M_dispose() noexcept |
553 | { |
554 | allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); |
555 | } |
556 | |
557 | |
558 | virtual void |
559 | _M_destroy() noexcept |
560 | { |
561 | __allocator_type __a(_M_impl._M_alloc()); |
562 | __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; |
563 | this->~_Sp_counted_ptr_inplace(); |
564 | } |
565 | |
566 | private: |
567 | friend class __shared_count<_Lp>; |
568 | |
569 | |
570 | |
571 | virtual void* |
572 | _M_get_deleter(const std::type_info& __ti) noexcept override |
573 | { |
574 | |
575 | |
576 | if (&__ti == &_Sp_make_shared_tag::_S_ti()) |
577 | return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr()); |
578 | #if __cpp_rtti199711 |
579 | |
580 | |
581 | else if (__ti == typeid(_Sp_make_shared_tag)) |
582 | return const_cast<typename remove_cv<_Tp>::type*>(_M_ptr()); |
583 | #else |
584 | |
585 | |
586 | |
587 | |
588 | #endif |
589 | return nullptr; |
590 | } |
591 | |
592 | _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } |
593 | |
594 | _Impl _M_impl; |
595 | }; |
596 | |
597 | |
598 | struct __sp_array_delete |
599 | { |
600 | template<typename _Yp> |
601 | void operator()(_Yp* __p) const { delete[] __p; } |
602 | }; |
603 | |
604 | template<_Lock_policy _Lp> |
605 | class __shared_count |
606 | { |
607 | template<typename _Tp> |
608 | struct __not_alloc_shared_tag { using type = void; }; |
609 | |
610 | template<typename _Tp> |
611 | struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; |
612 | |
613 | public: |
614 | constexpr __shared_count() noexcept : _M_pi(0) |
615 | { } |
616 | |
617 | template<typename _Ptr> |
618 | explicit |
619 | __shared_count(_Ptr __p) : _M_pi(0) |
620 | { |
621 | __trytry |
622 | { |
623 | _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); |
624 | } |
625 | __catch(...)catch(...) |
626 | { |
627 | delete __p; |
628 | __throw_exception_againthrow; |
629 | } |
630 | } |
631 | |
632 | template<typename _Ptr> |
633 | __shared_count(_Ptr __p, false_type) |
634 | : __shared_count(__p) |
635 | { } |
636 | |
637 | template<typename _Ptr> |
638 | __shared_count(_Ptr __p, true_type) |
639 | : __shared_count(__p, __sp_array_delete{}, allocator<void>()) |
640 | { } |
641 | |
642 | template<typename _Ptr, typename _Deleter, |
643 | typename = typename __not_alloc_shared_tag<_Deleter>::type> |
644 | __shared_count(_Ptr __p, _Deleter __d) |
645 | : __shared_count(__p, std::move(__d), allocator<void>()) |
646 | { } |
647 | |
648 | template<typename _Ptr, typename _Deleter, typename _Alloc, |
649 | typename = typename __not_alloc_shared_tag<_Deleter>::type> |
650 | __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) |
651 | { |
652 | typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; |
653 | __trytry |
654 | { |
655 | typename _Sp_cd_type::__allocator_type __a2(__a); |
656 | auto __guard = std::__allocate_guarded(__a2); |
657 | _Sp_cd_type* __mem = __guard.get(); |
658 | ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); |
659 | _M_pi = __mem; |
660 | __guard = nullptr; |
661 | } |
662 | __catch(...)catch(...) |
663 | { |
664 | __d(__p); |
665 | __throw_exception_againthrow; |
666 | } |
667 | } |
668 | |
669 | template<typename _Tp, typename _Alloc, typename... _Args> |
670 | __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, |
671 | _Args&&... __args) |
672 | { |
673 | typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; |
674 | typename _Sp_cp_type::__allocator_type __a2(__a._M_a); |
675 | auto __guard = std::__allocate_guarded(__a2); |
676 | _Sp_cp_type* __mem = __guard.get(); |
677 | auto __pi = ::new (__mem) |
678 | _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); |
679 | __guard = nullptr; |
680 | _M_pi = __pi; |
681 | __p = __pi->_M_ptr(); |
682 | } |
683 | |
684 | #if _GLIBCXX_USE_DEPRECATED1 |
685 | #pragma GCC diagnostic push |
686 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
687 | |
688 | template<typename _Tp> |
689 | explicit |
690 | __shared_count(std::auto_ptr<_Tp>&& __r); |
691 | #pragma GCC diagnostic pop |
692 | #endif |
693 | |
694 | |
695 | template<typename _Tp, typename _Del> |
696 | explicit |
697 | __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) |
698 | { |
699 | |
700 | |
701 | if (__r.get() == nullptr) |
702 | return; |
703 | |
704 | using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; |
705 | using _Del2 = typename conditional<is_reference<_Del>::value, |
706 | reference_wrapper<typename remove_reference<_Del>::type>, |
707 | _Del>::type; |
708 | using _Sp_cd_type |
709 | = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>; |
710 | using _Alloc = allocator<_Sp_cd_type>; |
711 | using _Alloc_traits = allocator_traits<_Alloc>; |
712 | _Alloc __a; |
713 | _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); |
714 | _Alloc_traits::construct(__a, __mem, __r.release(), |
715 | __r.get_deleter()); |
716 | _M_pi = __mem; |
717 | } |
718 | |
719 | |
720 | explicit __shared_count(const __weak_count<_Lp>& __r); |
721 | |
722 | |
723 | explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t); |
724 | |
725 | ~__shared_count() noexcept |
726 | { |
727 | if (_M_pi != nullptr) |
728 | _M_pi->_M_release(); |
729 | } |
730 | |
731 | __shared_count(const __shared_count& __r) noexcept |
732 | : _M_pi(__r._M_pi) |
733 | { |
734 | if (_M_pi != 0) |
735 | _M_pi->_M_add_ref_copy(); |
736 | } |
737 | |
738 | __shared_count& |
739 | operator=(const __shared_count& __r) noexcept |
740 | { |
741 | _Sp_counted_base<_Lp>* __tmp = __r._M_pi; |
742 | if (__tmp != _M_pi) |
| |
| |
743 | { |
744 | if (__tmp != 0) |
| 12 | | Assuming '__tmp' is equal to null | |
|
| |
| 34 | | Assuming '__tmp' is equal to null | |
|
| |
745 | __tmp->_M_add_ref_copy(); |
746 | if (_M_pi != 0) |
| |
| |
747 | _M_pi->_M_release(); |
| 15 | | Calling '_Sp_counted_base::_M_release' | |
|
| 24 | | Returning; memory was released | |
|
| 37 | | Calling '_Sp_counted_base::_M_release' | |
|
748 | _M_pi = __tmp; |
749 | } |
750 | return *this; |
751 | } |
752 | |
753 | void |
754 | _M_swap(__shared_count& __r) noexcept |
755 | { |
756 | _Sp_counted_base<_Lp>* __tmp = __r._M_pi; |
757 | __r._M_pi = _M_pi; |
758 | _M_pi = __tmp; |
759 | } |
760 | |
761 | long |
762 | _M_get_use_count() const noexcept |
763 | { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } |
764 | |
765 | bool |
766 | _M_unique() const noexcept |
767 | { return this->_M_get_use_count() == 1; } |
768 | |
769 | void* |
770 | _M_get_deleter(const std::type_info& __ti) const noexcept |
771 | { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } |
772 | |
773 | bool |
774 | _M_less(const __shared_count& __rhs) const noexcept |
775 | { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } |
776 | |
777 | bool |
778 | _M_less(const __weak_count<_Lp>& __rhs) const noexcept |
779 | { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } |
780 | |
781 | |
782 | friend inline bool |
783 | operator==(const __shared_count& __a, const __shared_count& __b) noexcept |
784 | { return __a._M_pi == __b._M_pi; } |
785 | |
786 | private: |
787 | friend class __weak_count<_Lp>; |
788 | |
789 | _Sp_counted_base<_Lp>* _M_pi; |
790 | }; |
791 | |
792 | |
793 | template<_Lock_policy _Lp> |
794 | class __weak_count |
795 | { |
796 | public: |
797 | constexpr __weak_count() noexcept : _M_pi(nullptr) |
798 | { } |
799 | |
800 | __weak_count(const __shared_count<_Lp>& __r) noexcept |
801 | : _M_pi(__r._M_pi) |
802 | { |
803 | if (_M_pi != nullptr) |
804 | _M_pi->_M_weak_add_ref(); |
805 | } |
806 | |
807 | __weak_count(const __weak_count& __r) noexcept |
808 | : _M_pi(__r._M_pi) |
809 | { |
810 | if (_M_pi != nullptr) |
811 | _M_pi->_M_weak_add_ref(); |
812 | } |
813 | |
814 | __weak_count(__weak_count&& __r) noexcept |
815 | : _M_pi(__r._M_pi) |
816 | { __r._M_pi = nullptr; } |
817 | |
818 | ~__weak_count() noexcept |
819 | { |
820 | if (_M_pi != nullptr) |
821 | _M_pi->_M_weak_release(); |
822 | } |
823 | |
824 | __weak_count& |
825 | operator=(const __shared_count<_Lp>& __r) noexcept |
826 | { |
827 | _Sp_counted_base<_Lp>* __tmp = __r._M_pi; |
828 | if (__tmp != nullptr) |
829 | __tmp->_M_weak_add_ref(); |
830 | if (_M_pi != nullptr) |
831 | _M_pi->_M_weak_release(); |
832 | _M_pi = __tmp; |
833 | return *this; |
834 | } |
835 | |
836 | __weak_count& |
837 | operator=(const __weak_count& __r) noexcept |
838 | { |
839 | _Sp_counted_base<_Lp>* __tmp = __r._M_pi; |
840 | if (__tmp != nullptr) |
841 | __tmp->_M_weak_add_ref(); |
842 | if (_M_pi != nullptr) |
843 | _M_pi->_M_weak_release(); |
844 | _M_pi = __tmp; |
845 | return *this; |
846 | } |
847 | |
848 | __weak_count& |
849 | operator=(__weak_count&& __r) noexcept |
850 | { |
851 | if (_M_pi != nullptr) |
852 | _M_pi->_M_weak_release(); |
853 | _M_pi = __r._M_pi; |
854 | __r._M_pi = nullptr; |
855 | return *this; |
856 | } |
857 | |
858 | void |
859 | _M_swap(__weak_count& __r) noexcept |
860 | { |
861 | _Sp_counted_base<_Lp>* __tmp = __r._M_pi; |
862 | __r._M_pi = _M_pi; |
863 | _M_pi = __tmp; |
864 | } |
865 | |
866 | long |
867 | _M_get_use_count() const noexcept |
868 | { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; } |
869 | |
870 | bool |
871 | _M_less(const __weak_count& __rhs) const noexcept |
872 | { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } |
873 | |
874 | bool |
875 | _M_less(const __shared_count<_Lp>& __rhs) const noexcept |
876 | { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } |
877 | |
878 | |
879 | friend inline bool |
880 | operator==(const __weak_count& __a, const __weak_count& __b) noexcept |
881 | { return __a._M_pi == __b._M_pi; } |
882 | |
883 | private: |
884 | friend class __shared_count<_Lp>; |
885 | |
886 | _Sp_counted_base<_Lp>* _M_pi; |
887 | }; |
888 | |
889 | |
890 | template<_Lock_policy _Lp> |
891 | inline |
892 | __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) |
893 | : _M_pi(__r._M_pi) |
894 | { |
895 | if (_M_pi != nullptr) |
896 | _M_pi->_M_add_ref_lock(); |
897 | else |
898 | __throw_bad_weak_ptr(); |
899 | } |
900 | |
901 | |
902 | template<_Lock_policy _Lp> |
903 | inline |
904 | __shared_count<_Lp>:: |
905 | __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) |
906 | : _M_pi(__r._M_pi) |
907 | { |
908 | if (_M_pi != nullptr) |
909 | if (!_M_pi->_M_add_ref_lock_nothrow()) |
910 | _M_pi = nullptr; |
911 | } |
912 | |
913 | #define __cpp_lib_shared_ptr_arrays201603 201603 |
914 | |
915 | |
916 | |
917 | |
918 | |
919 | template<typename _Yp_ptr, typename _Tp_ptr> |
920 | struct __sp_compatible_with |
921 | : false_type |
922 | { }; |
923 | |
924 | template<typename _Yp, typename _Tp> |
925 | struct __sp_compatible_with<_Yp*, _Tp*> |
926 | : is_convertible<_Yp*, _Tp*>::type |
927 | { }; |
928 | |
929 | template<typename _Up, size_t _Nm> |
930 | struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> |
931 | : true_type |
932 | { }; |
933 | |
934 | template<typename _Up, size_t _Nm> |
935 | struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> |
936 | : true_type |
937 | { }; |
938 | |
939 | template<typename _Up, size_t _Nm> |
940 | struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> |
941 | : true_type |
942 | { }; |
943 | |
944 | template<typename _Up, size_t _Nm> |
945 | struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> |
946 | : true_type |
947 | { }; |
948 | |
949 | |
950 | template<typename _Up, size_t _Nm, typename _Yp, typename = void> |
951 | struct __sp_is_constructible_arrN |
952 | : false_type |
953 | { }; |
954 | |
955 | template<typename _Up, size_t _Nm, typename _Yp> |
956 | struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> |
957 | : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type |
958 | { }; |
959 | |
960 | |
961 | template<typename _Up, typename _Yp, typename = void> |
962 | struct __sp_is_constructible_arr |
963 | : false_type |
964 | { }; |
965 | |
966 | template<typename _Up, typename _Yp> |
967 | struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> |
968 | : is_convertible<_Yp(*)[], _Up(*)[]>::type |
969 | { }; |
970 | |
971 | |
972 | template<typename _Tp, typename _Yp> |
973 | struct __sp_is_constructible; |
974 | |
975 | |
976 | template<typename _Up, size_t _Nm, typename _Yp> |
977 | struct __sp_is_constructible<_Up[_Nm], _Yp> |
978 | : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type |
979 | { }; |
980 | |
981 | |
982 | template<typename _Up, typename _Yp> |
983 | struct __sp_is_constructible<_Up[], _Yp> |
984 | : __sp_is_constructible_arr<_Up, _Yp>::type |
985 | { }; |
986 | |
987 | |
988 | template<typename _Tp, typename _Yp> |
989 | struct __sp_is_constructible |
990 | : is_convertible<_Yp*, _Tp*>::type |
991 | { }; |
992 | |
993 | |
994 | |
995 | template<typename _Tp, _Lock_policy _Lp, |
996 | bool = is_array<_Tp>::value, bool = is_void<_Tp>::value> |
997 | class __shared_ptr_access |
998 | { |
999 | public: |
1000 | using element_type = _Tp; |
1001 | |
1002 | element_type& |
1003 | operator*() const noexcept |
1004 | { |
1005 | __glibcxx_assert(_M_get() != nullptr); |
1006 | return *_M_get(); |
1007 | } |
1008 | |
1009 | element_type* |
1010 | operator->() const noexcept |
1011 | { |
1012 | _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); |
1013 | return _M_get(); |
1014 | } |
1015 | |
1016 | private: |
1017 | element_type* |
1018 | _M_get() const noexcept |
1019 | { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); } |
1020 | }; |
1021 | |
1022 | |
1023 | template<typename _Tp, _Lock_policy _Lp> |
1024 | class __shared_ptr_access<_Tp, _Lp, false, true> |
1025 | { |
1026 | public: |
1027 | using element_type = _Tp; |
1028 | |
1029 | element_type* |
1030 | operator->() const noexcept |
1031 | { |
1032 | auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); |
1033 | _GLIBCXX_DEBUG_PEDASSERT(__ptr != nullptr); |
1034 | return __ptr; |
1035 | } |
1036 | }; |
1037 | |
1038 | |
1039 | template<typename _Tp, _Lock_policy _Lp> |
1040 | class __shared_ptr_access<_Tp, _Lp, true, false> |
1041 | { |
1042 | public: |
1043 | using element_type = typename remove_extent<_Tp>::type; |
1044 | |
1045 | #if __cplusplus201103L <= 201402L |
1046 | [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]] |
1047 | element_type& |
1048 | operator*() const noexcept |
1049 | { |
1050 | __glibcxx_assert(_M_get() != nullptr); |
1051 | return *_M_get(); |
1052 | } |
1053 | |
1054 | [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]] |
1055 | element_type* |
1056 | operator->() const noexcept |
1057 | { |
1058 | _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr); |
1059 | return _M_get(); |
1060 | } |
1061 | #endif |
1062 | |
1063 | element_type& |
1064 | operator[](ptrdiff_t __i) const |
1065 | { |
1066 | __glibcxx_assert(_M_get() != nullptr); |
1067 | __glibcxx_assert(!extent<_Tp>::value || __i < extent<_Tp>::value); |
1068 | return _M_get()[__i]; |
1069 | } |
1070 | |
1071 | private: |
1072 | element_type* |
1073 | _M_get() const noexcept |
1074 | { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); } |
1075 | }; |
1076 | |
1077 | template<typename _Tp, _Lock_policy _Lp> |
1078 | class __shared_ptr |
1079 | : public __shared_ptr_access<_Tp, _Lp> |
1080 | { |
1081 | public: |
1082 | using element_type = typename remove_extent<_Tp>::type; |
1083 | |
1084 | private: |
1085 | |
1086 | template<typename _Yp> |
1087 | using _SafeConv |
1088 | = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; |
1089 | |
1090 | |
1091 | template<typename _Yp, typename _Res = void> |
1092 | using _Compatible = typename |
1093 | enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; |
1094 | |
1095 | |
1096 | template<typename _Yp> |
1097 | using _Assignable = _Compatible<_Yp, __shared_ptr&>; |
1098 | |
1099 | |
1100 | template<typename _Yp, typename _Del, typename _Res = void, |
1101 | typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer> |
1102 | using _UniqCompatible = typename enable_if<__and_< |
1103 | __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*> |
1104 | >::value, _Res>::type; |
1105 | |
1106 | |
1107 | template<typename _Yp, typename _Del> |
1108 | using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; |
1109 | |
1110 | public: |
1111 | |
1112 | #if __cplusplus201103L > 201402L |
1113 | using weak_type = __weak_ptr<_Tp, _Lp>; |
1114 | #endif |
1115 | |
1116 | constexpr __shared_ptr() noexcept |
1117 | : _M_ptr(0), _M_refcount() |
1118 | { } |
1119 | |
1120 | template<typename _Yp, typename = _SafeConv<_Yp>> |
1121 | explicit |
1122 | __shared_ptr(_Yp* __p) |
1123 | : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) |
1124 | { |
1125 | static_assert( !is_void<_Yp>::value, "incomplete type" ); |
1126 | static_assert( sizeof(_Yp) > 0, "incomplete type" ); |
1127 | _M_enable_shared_from_this_with(__p); |
1128 | } |
1129 | |
1130 | template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>> |
1131 | __shared_ptr(_Yp* __p, _Deleter __d) |
1132 | : _M_ptr(__p), _M_refcount(__p, std::move(__d)) |
1133 | { |
1134 | static_assert(__is_invocable<_Deleter&, _Yp*&>::value, |
1135 | "deleter expression d(p) is well-formed"); |
1136 | _M_enable_shared_from_this_with(__p); |
1137 | } |
1138 | |
1139 | template<typename _Yp, typename _Deleter, typename _Alloc, |
1140 | typename = _SafeConv<_Yp>> |
1141 | __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) |
1142 | : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) |
1143 | { |
1144 | static_assert(__is_invocable<_Deleter&, _Yp*&>::value, |
1145 | "deleter expression d(p) is well-formed"); |
1146 | _M_enable_shared_from_this_with(__p); |
1147 | } |
1148 | |
1149 | template<typename _Deleter> |
1150 | __shared_ptr(nullptr_t __p, _Deleter __d) |
1151 | : _M_ptr(0), _M_refcount(__p, std::move(__d)) |
1152 | { } |
1153 | |
1154 | template<typename _Deleter, typename _Alloc> |
1155 | __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) |
1156 | : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a)) |
1157 | { } |
1158 | |
1159 | template<typename _Yp> |
1160 | __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r, |
1161 | element_type* __p) noexcept |
1162 | : _M_ptr(__p), _M_refcount(__r._M_refcount) |
1163 | { } |
1164 | |
1165 | __shared_ptr(const __shared_ptr&) noexcept = default; |
1166 | __shared_ptr& operator=(const __shared_ptr&) noexcept = default; |
| 10 | | Calling copy assignment operator for '__shared_count' | |
|
| 25 | | Returning; memory was released | |
|
| 32 | | Calling copy assignment operator for '__shared_count' | |
|
1167 | ~__shared_ptr() = default; |
1168 | |
1169 | template<typename _Yp, typename = _Compatible<_Yp>> |
1170 | __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept |
1171 | : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) |
1172 | { } |
1173 | |
1174 | __shared_ptr(__shared_ptr&& __r) noexcept |
1175 | : _M_ptr(__r._M_ptr), _M_refcount() |
1176 | { |
1177 | _M_refcount._M_swap(__r._M_refcount); |
1178 | __r._M_ptr = 0; |
1179 | } |
1180 | |
1181 | template<typename _Yp, typename = _Compatible<_Yp>> |
1182 | __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept |
1183 | : _M_ptr(__r._M_ptr), _M_refcount() |
1184 | { |
1185 | _M_refcount._M_swap(__r._M_refcount); |
1186 | __r._M_ptr = 0; |
1187 | } |
1188 | |
1189 | template<typename _Yp, typename = _Compatible<_Yp>> |
1190 | explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) |
1191 | : _M_refcount(__r._M_refcount) |
1192 | { |
1193 | |
1194 | |
1195 | _M_ptr = __r._M_ptr; |
1196 | } |
1197 | |
1198 | |
1199 | template<typename _Yp, typename _Del, |
1200 | typename = _UniqCompatible<_Yp, _Del>> |
1201 | __shared_ptr(unique_ptr<_Yp, _Del>&& __r) |
1202 | : _M_ptr(__r.get()), _M_refcount() |
1203 | { |
1204 | auto __raw = __to_address(__r.get()); |
1205 | _M_refcount = __shared_count<_Lp>(std::move(__r)); |
1206 | _M_enable_shared_from_this_with(__raw); |
1207 | } |
1208 | |
1209 | #if __cplusplus201103L <= 201402L && _GLIBCXX_USE_DEPRECATED1 |
1210 | protected: |
1211 | |
1212 | template<typename _Tp1, typename _Del, |
1213 | typename enable_if<__and_< |
1214 | __not_<is_array<_Tp>>, is_array<_Tp1>, |
1215 | is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*> |
1216 | >::value, bool>::type = true> |
1217 | __shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete) |
1218 | : _M_ptr(__r.get()), _M_refcount() |
1219 | { |
1220 | auto __raw = __to_address(__r.get()); |
1221 | _M_refcount = __shared_count<_Lp>(std::move(__r)); |
1222 | _M_enable_shared_from_this_with(__raw); |
1223 | } |
1224 | public: |
1225 | #endif |
1226 | |
1227 | #if _GLIBCXX_USE_DEPRECATED1 |
1228 | #pragma GCC diagnostic push |
1229 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
1230 | |
1231 | template<typename _Yp, typename = _Compatible<_Yp>> |
1232 | __shared_ptr(auto_ptr<_Yp>&& __r); |
1233 | #pragma GCC diagnostic pop |
1234 | #endif |
1235 | |
1236 | constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } |
1237 | |
1238 | template<typename _Yp> |
1239 | _Assignable<_Yp> |
1240 | operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept |
1241 | { |
1242 | _M_ptr = __r._M_ptr; |
1243 | _M_refcount = __r._M_refcount; |
1244 | return *this; |
1245 | } |
1246 | |
1247 | #if _GLIBCXX_USE_DEPRECATED1 |
1248 | #pragma GCC diagnostic push |
1249 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
1250 | template<typename _Yp> |
1251 | _Assignable<_Yp> |
1252 | operator=(auto_ptr<_Yp>&& __r) |
1253 | { |
1254 | __shared_ptr(std::move(__r)).swap(*this); |
1255 | return *this; |
1256 | } |
1257 | #pragma GCC diagnostic pop |
1258 | #endif |
1259 | |
1260 | __shared_ptr& |
1261 | operator=(__shared_ptr&& __r) noexcept |
1262 | { |
1263 | __shared_ptr(std::move(__r)).swap(*this); |
1264 | return *this; |
1265 | } |
1266 | |
1267 | template<class _Yp> |
1268 | _Assignable<_Yp> |
1269 | operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept |
1270 | { |
1271 | __shared_ptr(std::move(__r)).swap(*this); |
1272 | return *this; |
1273 | } |
1274 | |
1275 | template<typename _Yp, typename _Del> |
1276 | _UniqAssignable<_Yp, _Del> |
1277 | operator=(unique_ptr<_Yp, _Del>&& __r) |
1278 | { |
1279 | __shared_ptr(std::move(__r)).swap(*this); |
1280 | return *this; |
1281 | } |
1282 | |
1283 | void |
1284 | reset() noexcept |
1285 | { __shared_ptr().swap(*this); } |
1286 | |
1287 | template<typename _Yp> |
1288 | _SafeConv<_Yp> |
1289 | reset(_Yp* __p) |
1290 | { |
1291 | |
1292 | __glibcxx_assert(__p == 0 || __p != _M_ptr); |
1293 | __shared_ptr(__p).swap(*this); |
1294 | } |
1295 | |
1296 | template<typename _Yp, typename _Deleter> |
1297 | _SafeConv<_Yp> |
1298 | reset(_Yp* __p, _Deleter __d) |
1299 | { __shared_ptr(__p, std::move(__d)).swap(*this); } |
1300 | |
1301 | template<typename _Yp, typename _Deleter, typename _Alloc> |
1302 | _SafeConv<_Yp> |
1303 | reset(_Yp* __p, _Deleter __d, _Alloc __a) |
1304 | { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } |
1305 | |
1306 | element_type* |
1307 | get() const noexcept |
1308 | { return _M_ptr; } |
1309 | |
1310 | explicit operator bool() const |
1311 | { return _M_ptr == 0 ? false : true; } |
1312 | |
1313 | bool |
1314 | unique() const noexcept |
1315 | { return _M_refcount._M_unique(); } |
1316 | |
1317 | long |
1318 | use_count() const noexcept |
1319 | { return _M_refcount._M_get_use_count(); } |
1320 | |
1321 | void |
1322 | swap(__shared_ptr<_Tp, _Lp>& __other) noexcept |
1323 | { |
1324 | std::swap(_M_ptr, __other._M_ptr); |
1325 | _M_refcount._M_swap(__other._M_refcount); |
1326 | } |
1327 | |
1328 | template<typename _Tp1> |
1329 | bool |
1330 | owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept |
1331 | { return _M_refcount._M_less(__rhs._M_refcount); } |
1332 | |
1333 | template<typename _Tp1> |
1334 | bool |
1335 | owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept |
1336 | { return _M_refcount._M_less(__rhs._M_refcount); } |
1337 | |
1338 | protected: |
1339 | |
1340 | template<typename _Alloc, typename... _Args> |
1341 | __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) |
1342 | : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...) |
1343 | { _M_enable_shared_from_this_with(_M_ptr); } |
1344 | |
1345 | template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc, |
1346 | typename... _Args> |
1347 | friend __shared_ptr<_Tp1, _Lp1> |
1348 | __allocate_shared(const _Alloc& __a, _Args&&... __args); |
1349 | |
1350 | |
1351 | |
1352 | __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) |
1353 | : _M_refcount(__r._M_refcount, std::nothrow) |
1354 | { |
1355 | _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; |
1356 | } |
1357 | |
1358 | friend class __weak_ptr<_Tp, _Lp>; |
1359 | |
1360 | private: |
1361 | |
1362 | template<typename _Yp> |
1363 | using __esft_base_t = decltype(__enable_shared_from_this_base( |
1364 | std::declval<const __shared_count<_Lp>&>(), |
1365 | std::declval<_Yp*>())); |
1366 | |
1367 | |
1368 | template<typename _Yp, typename = void> |
1369 | struct __has_esft_base |
1370 | : false_type { }; |
1371 | |
1372 | template<typename _Yp> |
1373 | struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> |
1374 | : __not_<is_array<_Tp>> { }; |
1375 | |
1376 | template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type> |
1377 | typename enable_if<__has_esft_base<_Yp2>::value>::type |
1378 | _M_enable_shared_from_this_with(_Yp* __p) noexcept |
1379 | { |
1380 | if (auto __base = __enable_shared_from_this_base(_M_refcount, __p)) |
1381 | __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); |
1382 | } |
1383 | |
1384 | template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type> |
1385 | typename enable_if<!__has_esft_base<_Yp2>::value>::type |
1386 | _M_enable_shared_from_this_with(_Yp*) noexcept |
1387 | { } |
1388 | |
1389 | void* |
1390 | _M_get_deleter(const std::type_info& __ti) const noexcept |
1391 | { return _M_refcount._M_get_deleter(__ti); } |
1392 | |
1393 | template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; |
1394 | template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; |
1395 | |
1396 | template<typename _Del, typename _Tp1, _Lock_policy _Lp1> |
1397 | friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; |
1398 | |
1399 | template<typename _Del, typename _Tp1> |
1400 | friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept; |
1401 | |
1402 | element_type* _M_ptr; |
1403 | __shared_count<_Lp> _M_refcount; |
1404 | }; |
1405 | |
1406 | |
1407 | |
1408 | template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> |
1409 | inline bool |
1410 | operator==(const __shared_ptr<_Tp1, _Lp>& __a, |
1411 | const __shared_ptr<_Tp2, _Lp>& __b) noexcept |
1412 | { return __a.get() == __b.get(); } |
1413 | |
1414 | template<typename _Tp, _Lock_policy _Lp> |
1415 | inline bool |
1416 | operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept |
1417 | { return !__a; } |
1418 | |
1419 | template<typename _Tp, _Lock_policy _Lp> |
1420 | inline bool |
1421 | operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept |
1422 | { return !__a; } |
1423 | |
1424 | template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> |
1425 | inline bool |
1426 | operator!=(const __shared_ptr<_Tp1, _Lp>& __a, |
1427 | const __shared_ptr<_Tp2, _Lp>& __b) noexcept |
1428 | { return __a.get() != __b.get(); } |
1429 | |
1430 | template<typename _Tp, _Lock_policy _Lp> |
1431 | inline bool |
1432 | operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept |
1433 | { return (bool)__a; } |
1434 | |
1435 | template<typename _Tp, _Lock_policy _Lp> |
1436 | inline bool |
1437 | operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept |
1438 | { return (bool)__a; } |
1439 | |
1440 | template<typename _Tp, typename _Up, _Lock_policy _Lp> |
1441 | inline bool |
1442 | operator<(const __shared_ptr<_Tp, _Lp>& __a, |
1443 | const __shared_ptr<_Up, _Lp>& __b) noexcept |
1444 | { |
1445 | using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; |
1446 | using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type; |
1447 | using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; |
1448 | return less<_Vp>()(__a.get(), __b.get()); |
1449 | } |
1450 | |
1451 | template<typename _Tp, _Lock_policy _Lp> |
1452 | inline bool |
1453 | operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept |
1454 | { |
1455 | using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; |
1456 | return less<_Tp_elt*>()(__a.get(), nullptr); |
1457 | } |
1458 | |
1459 | template<typename _Tp, _Lock_policy _Lp> |
1460 | inline bool |
1461 | operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept |
1462 | { |
1463 | using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; |
1464 | return less<_Tp_elt*>()(nullptr, __a.get()); |
1465 | } |
1466 | |
1467 | template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> |
1468 | inline bool |
1469 | operator<=(const __shared_ptr<_Tp1, _Lp>& __a, |
1470 | const __shared_ptr<_Tp2, _Lp>& __b) noexcept |
1471 | { return !(__b < __a); } |
1472 | |
1473 | template<typename _Tp, _Lock_policy _Lp> |
1474 | inline bool |
1475 | operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept |
1476 | { return !(nullptr < __a); } |
1477 | |
1478 | template<typename _Tp, _Lock_policy _Lp> |
1479 | inline bool |
1480 | operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept |
1481 | { return !(__a < nullptr); } |
1482 | |
1483 | template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> |
1484 | inline bool |
1485 | operator>(const __shared_ptr<_Tp1, _Lp>& __a, |
1486 | const __shared_ptr<_Tp2, _Lp>& __b) noexcept |
1487 | { return (__b < __a); } |
1488 | |
1489 | template<typename _Tp, _Lock_policy _Lp> |
1490 | inline bool |
1491 | operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept |
1492 | { return nullptr < __a; } |
1493 | |
1494 | template<typename _Tp, _Lock_policy _Lp> |
1495 | inline bool |
1496 | operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept |
1497 | { return __a < nullptr; } |
1498 | |
1499 | template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> |
1500 | inline bool |
1501 | operator>=(const __shared_ptr<_Tp1, _Lp>& __a, |
1502 | const __shared_ptr<_Tp2, _Lp>& __b) noexcept |
1503 | { return !(__a < __b); } |
1504 | |
1505 | template<typename _Tp, _Lock_policy _Lp> |
1506 | inline bool |
1507 | operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept |
1508 | { return !(__a < nullptr); } |
1509 | |
1510 | template<typename _Tp, _Lock_policy _Lp> |
1511 | inline bool |
1512 | operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept |
1513 | { return !(nullptr < __a); } |
1514 | |
1515 | template<typename _Sp> |
1516 | struct _Sp_less : public binary_function<_Sp, _Sp, bool> |
1517 | { |
1518 | bool |
1519 | operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept |
1520 | { |
1521 | typedef typename _Sp::element_type element_type; |
1522 | return std::less<element_type*>()(__lhs.get(), __rhs.get()); |
1523 | } |
1524 | }; |
1525 | |
1526 | template<typename _Tp, _Lock_policy _Lp> |
1527 | struct less<__shared_ptr<_Tp, _Lp>> |
1528 | : public _Sp_less<__shared_ptr<_Tp, _Lp>> |
1529 | { }; |
1530 | |
1531 | |
1532 | template<typename _Tp, _Lock_policy _Lp> |
1533 | inline void |
1534 | swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept |
1535 | { __a.swap(__b); } |
1536 | |
1537 | |
1538 | |
1539 | |
1540 | |
1541 | |
1542 | |
1543 | |
1544 | template<typename _Tp, typename _Tp1, _Lock_policy _Lp> |
1545 | inline __shared_ptr<_Tp, _Lp> |
1546 | static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept |
1547 | { |
1548 | using _Sp = __shared_ptr<_Tp, _Lp>; |
1549 | return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get())); |
1550 | } |
1551 | |
1552 | |
1553 | |
1554 | |
1555 | |
1556 | |
1557 | template<typename _Tp, typename _Tp1, _Lock_policy _Lp> |
1558 | inline __shared_ptr<_Tp, _Lp> |
1559 | const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept |
1560 | { |
1561 | using _Sp = __shared_ptr<_Tp, _Lp>; |
1562 | return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get())); |
1563 | } |
1564 | |
1565 | |
1566 | |
1567 | |
1568 | |
1569 | |
1570 | template<typename _Tp, typename _Tp1, _Lock_policy _Lp> |
1571 | inline __shared_ptr<_Tp, _Lp> |
1572 | dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept |
1573 | { |
1574 | using _Sp = __shared_ptr<_Tp, _Lp>; |
1575 | if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get())) |
1576 | return _Sp(__r, __p); |
1577 | return _Sp(); |
1578 | } |
1579 | |
1580 | #if __cplusplus201103L > 201402L |
1581 | template<typename _Tp, typename _Tp1, _Lock_policy _Lp> |
1582 | inline __shared_ptr<_Tp, _Lp> |
1583 | reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept |
1584 | { |
1585 | using _Sp = __shared_ptr<_Tp, _Lp>; |
1586 | return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get())); |
1587 | } |
1588 | #endif |
1589 | |
1590 | template<typename _Tp, _Lock_policy _Lp> |
1591 | class __weak_ptr |
1592 | { |
1593 | template<typename _Yp, typename _Res = void> |
1594 | using _Compatible = typename |
1595 | enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; |
1596 | |
1597 | |
1598 | template<typename _Yp> |
1599 | using _Assignable = _Compatible<_Yp, __weak_ptr&>; |
1600 | |
1601 | public: |
1602 | using element_type = typename remove_extent<_Tp>::type; |
1603 | |
1604 | constexpr __weak_ptr() noexcept |
1605 | : _M_ptr(nullptr), _M_refcount() |
1606 | { } |
1607 | |
1608 | __weak_ptr(const __weak_ptr&) noexcept = default; |
1609 | |
1610 | ~__weak_ptr() = default; |
1611 | |
1612 | |
1613 | |
1614 | |
1615 | |
1616 | |
1617 | |
1618 | |
1619 | |
1620 | |
1621 | |
1622 | |
1623 | |
1624 | |
1625 | |
1626 | template<typename _Yp, typename = _Compatible<_Yp>> |
1627 | __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept |
1628 | : _M_refcount(__r._M_refcount) |
1629 | { _M_ptr = __r.lock().get(); } |
1630 | |
1631 | template<typename _Yp, typename = _Compatible<_Yp>> |
1632 | __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept |
1633 | : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) |
1634 | { } |
1635 | |
1636 | __weak_ptr(__weak_ptr&& __r) noexcept |
1637 | : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount)) |
1638 | { __r._M_ptr = nullptr; } |
1639 | |
1640 | template<typename _Yp, typename = _Compatible<_Yp>> |
1641 | __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept |
1642 | : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount)) |
1643 | { __r._M_ptr = nullptr; } |
1644 | |
1645 | __weak_ptr& |
1646 | operator=(const __weak_ptr& __r) noexcept = default; |
1647 | |
1648 | template<typename _Yp> |
1649 | _Assignable<_Yp> |
1650 | operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept |
1651 | { |
1652 | _M_ptr = __r.lock().get(); |
1653 | _M_refcount = __r._M_refcount; |
1654 | return *this; |
1655 | } |
1656 | |
1657 | template<typename _Yp> |
1658 | _Assignable<_Yp> |
1659 | operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept |
1660 | { |
1661 | _M_ptr = __r._M_ptr; |
1662 | _M_refcount = __r._M_refcount; |
1663 | return *this; |
1664 | } |
1665 | |
1666 | __weak_ptr& |
1667 | operator=(__weak_ptr&& __r) noexcept |
1668 | { |
1669 | _M_ptr = __r._M_ptr; |
1670 | _M_refcount = std::move(__r._M_refcount); |
1671 | __r._M_ptr = nullptr; |
1672 | return *this; |
1673 | } |
1674 | |
1675 | template<typename _Yp> |
1676 | _Assignable<_Yp> |
1677 | operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept |
1678 | { |
1679 | _M_ptr = __r.lock().get(); |
1680 | _M_refcount = std::move(__r._M_refcount); |
1681 | __r._M_ptr = nullptr; |
1682 | return *this; |
1683 | } |
1684 | |
1685 | __shared_ptr<_Tp, _Lp> |
1686 | lock() const noexcept |
1687 | { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); } |
1688 | |
1689 | long |
1690 | use_count() const noexcept |
1691 | { return _M_refcount._M_get_use_count(); } |
1692 | |
1693 | bool |
1694 | expired() const noexcept |
1695 | { return _M_refcount._M_get_use_count() == 0; } |
1696 | |
1697 | template<typename _Tp1> |
1698 | bool |
1699 | owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept |
1700 | { return _M_refcount._M_less(__rhs._M_refcount); } |
1701 | |
1702 | template<typename _Tp1> |
1703 | bool |
1704 | owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept |
1705 | { return _M_refcount._M_less(__rhs._M_refcount); } |
1706 | |
1707 | void |
1708 | reset() noexcept |
1709 | { __weak_ptr().swap(*this); } |
1710 | |
1711 | void |
1712 | swap(__weak_ptr& __s) noexcept |
1713 | { |
1714 | std::swap(_M_ptr, __s._M_ptr); |
1715 | _M_refcount._M_swap(__s._M_refcount); |
1716 | } |
1717 | |
1718 | private: |
1719 | |
1720 | void |
1721 | _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept |
1722 | { |
1723 | if (use_count() == 0) |
1724 | { |
1725 | _M_ptr = __ptr; |
1726 | _M_refcount = __refcount; |
1727 | } |
1728 | } |
1729 | |
1730 | template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; |
1731 | template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; |
1732 | friend class __enable_shared_from_this<_Tp, _Lp>; |
1733 | friend class enable_shared_from_this<_Tp>; |
1734 | |
1735 | element_type* _M_ptr; |
1736 | __weak_count<_Lp> _M_refcount; |
1737 | }; |
1738 | |
1739 | |
1740 | template<typename _Tp, _Lock_policy _Lp> |
1741 | inline void |
1742 | swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept |
1743 | { __a.swap(__b); } |
1744 | |
1745 | template<typename _Tp, typename _Tp1> |
1746 | struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> |
1747 | { |
1748 | bool |
1749 | operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept |
1750 | { return __lhs.owner_before(__rhs); } |
1751 | |
1752 | bool |
1753 | operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept |
1754 | { return __lhs.owner_before(__rhs); } |
1755 | |
1756 | bool |
1757 | operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept |
1758 | { return __lhs.owner_before(__rhs); } |
1759 | }; |
1760 | |
1761 | template<> |
1762 | struct _Sp_owner_less<void, void> |
1763 | { |
1764 | template<typename _Tp, typename _Up> |
1765 | auto |
1766 | operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept |
1767 | -> decltype(__lhs.owner_before(__rhs)) |
1768 | { return __lhs.owner_before(__rhs); } |
1769 | |
1770 | using is_transparent = void; |
1771 | }; |
1772 | |
1773 | template<typename _Tp, _Lock_policy _Lp> |
1774 | struct owner_less<__shared_ptr<_Tp, _Lp>> |
1775 | : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> |
1776 | { }; |
1777 | |
1778 | template<typename _Tp, _Lock_policy _Lp> |
1779 | struct owner_less<__weak_ptr<_Tp, _Lp>> |
1780 | : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> |
1781 | { }; |
1782 | |
1783 | |
1784 | template<typename _Tp, _Lock_policy _Lp> |
1785 | class __enable_shared_from_this |
1786 | { |
1787 | protected: |
1788 | constexpr __enable_shared_from_this() noexcept { } |
1789 | |
1790 | __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } |
1791 | |
1792 | __enable_shared_from_this& |
1793 | operator=(const __enable_shared_from_this&) noexcept |
1794 | { return *this; } |
1795 | |
1796 | ~__enable_shared_from_this() { } |
1797 | |
1798 | public: |
1799 | __shared_ptr<_Tp, _Lp> |
1800 | shared_from_this() |
1801 | { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } |
1802 | |
1803 | __shared_ptr<const _Tp, _Lp> |
1804 | shared_from_this() const |
1805 | { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); } |
1806 | |
1807 | #if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11 |
1808 | __weak_ptr<_Tp, _Lp> |
1809 | weak_from_this() noexcept |
1810 | { return this->_M_weak_this; } |
1811 | |
1812 | __weak_ptr<const _Tp, _Lp> |
1813 | weak_from_this() const noexcept |
1814 | { return this->_M_weak_this; } |
1815 | #endif |
1816 | |
1817 | private: |
1818 | template<typename _Tp1> |
1819 | void |
1820 | _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept |
1821 | { _M_weak_this._M_assign(__p, __n); } |
1822 | |
1823 | friend const __enable_shared_from_this* |
1824 | __enable_shared_from_this_base(const __shared_count<_Lp>&, |
1825 | const __enable_shared_from_this* __p) |
1826 | { return __p; } |
1827 | |
1828 | template<typename, _Lock_policy> |
1829 | friend class __shared_ptr; |
1830 | |
1831 | mutable __weak_ptr<_Tp, _Lp> _M_weak_this; |
1832 | }; |
1833 | |
1834 | template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args> |
1835 | inline __shared_ptr<_Tp, _Lp> |
1836 | __allocate_shared(const _Alloc& __a, _Args&&... __args) |
1837 | { |
1838 | return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a}, |
1839 | std::forward<_Args>(__args)...); |
1840 | } |
1841 | |
1842 | template<typename _Tp, _Lock_policy _Lp, typename... _Args> |
1843 | inline __shared_ptr<_Tp, _Lp> |
1844 | __make_shared(_Args&&... __args) |
1845 | { |
1846 | typedef typename std::remove_const<_Tp>::type _Tp_nc; |
1847 | return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), |
1848 | std::forward<_Args>(__args)...); |
1849 | } |
1850 | |
1851 | |
1852 | template<typename _Tp, _Lock_policy _Lp> |
1853 | struct hash<__shared_ptr<_Tp, _Lp>> |
1854 | : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>> |
1855 | { |
1856 | size_t |
1857 | operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept |
1858 | { |
1859 | return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()( |
1860 | __s.get()); |
1861 | } |
1862 | }; |
1863 | |
1864 | _GLIBCXX_END_NAMESPACE_VERSION |
1865 | } |
1866 | |
1867 | #endif // _SHARED_PTR_BASE_H |