Line data Source code
1 : // shared_ptr and weak_ptr implementation details -*- C++ -*-
2 :
3 : // Copyright (C) 2007-2013 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
11 : // This library is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 :
16 : // Under Section 7 of GPL version 3, you are granted additional
17 : // permissions described in the GCC Runtime Library Exception, version
18 : // 3.1, as published by the Free Software Foundation.
19 :
20 : // You should have received a copy of the GNU General Public License and
21 : // a copy of the GCC Runtime Library Exception along with this program;
22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : // <http://www.gnu.org/licenses/>.
24 :
25 : // GCC Note: Based on files from version 1.32.0 of the Boost library.
26 :
27 : // shared_count.hpp
28 : // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
29 :
30 : // shared_ptr.hpp
31 : // Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32 : // Copyright (C) 2001, 2002, 2003 Peter Dimov
33 :
34 : // weak_ptr.hpp
35 : // Copyright (C) 2001, 2002, 2003 Peter Dimov
36 :
37 : // enable_shared_from_this.hpp
38 : // Copyright (C) 2002 Peter Dimov
39 :
40 : // Distributed under the Boost Software License, Version 1.0. (See
41 : // accompanying file LICENSE_1_0.txt or copy at
42 : // http://www.boost.org/LICENSE_1_0.txt)
43 :
44 : /** @file bits/shared_ptr_base.h
45 : * This is an internal header file, included by other library headers.
46 : * Do not attempt to use it directly. @headername{memory}
47 : */
48 :
49 : #ifndef _SHARED_PTR_BASE_H
50 : #define _SHARED_PTR_BASE_H 1
51 :
52 : namespace std _GLIBCXX_VISIBILITY(default)
53 : {
54 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
55 :
56 : #if _GLIBCXX_USE_DEPRECATED
57 : template<typename> class auto_ptr;
58 : #endif
59 :
60 : /**
61 : * @brief Exception possibly thrown by @c shared_ptr.
62 : * @ingroup exceptions
63 : */
64 : class bad_weak_ptr : public std::exception
65 : {
66 : public:
67 : virtual char const*
68 : what() const noexcept;
69 :
70 : virtual ~bad_weak_ptr() noexcept;
71 : };
72 :
73 : // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
74 : inline void
75 : __throw_bad_weak_ptr()
76 : { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); }
77 :
78 : using __gnu_cxx::_Lock_policy;
79 : using __gnu_cxx::__default_lock_policy;
80 : using __gnu_cxx::_S_single;
81 : using __gnu_cxx::_S_mutex;
82 : using __gnu_cxx::_S_atomic;
83 :
84 : // Empty helper class except when the template argument is _S_mutex.
85 : template<_Lock_policy _Lp>
86 : class _Mutex_base
87 : {
88 : protected:
89 : // The atomic policy uses fully-fenced builtins, single doesn't care.
90 : enum { _S_need_barriers = 0 };
91 : };
92 :
93 : template<>
94 : class _Mutex_base<_S_mutex>
95 : : public __gnu_cxx::__mutex
96 : {
97 : protected:
98 : // This policy is used when atomic builtins are not available.
99 : // The replacement atomic operations might not have the necessary
100 : // memory barriers.
101 : enum { _S_need_barriers = 1 };
102 : };
103 :
104 : template<_Lock_policy _Lp = __default_lock_policy>
105 : class _Sp_counted_base
106 : : public _Mutex_base<_Lp>
107 : {
108 : public:
109 : _Sp_counted_base() noexcept
110 12 : : _M_use_count(1), _M_weak_count(1) { }
111 :
112 : virtual
113 : ~_Sp_counted_base() noexcept
114 12 : { }
115 :
116 : // Called when _M_use_count drops to zero, to release the resources
117 : // managed by *this.
118 : virtual void
119 : _M_dispose() noexcept = 0;
120 :
121 : // Called when _M_weak_count drops to zero.
122 : virtual void
123 : _M_destroy() noexcept
124 0 : { delete this; }
125 :
126 : virtual void*
127 : _M_get_deleter(const std::type_info&) = 0;
128 :
129 : void
130 : _M_add_ref_copy()
131 : { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
132 :
133 : void
134 : _M_add_ref_lock();
135 :
136 : void
137 : _M_release() noexcept
138 : {
139 : // Be race-detector-friendly. For more info see bits/c++config.
140 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
141 24 : if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
142 : {
143 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
144 0 : _M_dispose();
145 : // There must be a memory barrier between dispose() and destroy()
146 : // to ensure that the effects of dispose() are observed in the
147 : // thread that runs destroy().
148 : // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
149 : if (_Mutex_base<_Lp>::_S_need_barriers)
150 : {
151 : _GLIBCXX_READ_MEM_BARRIER;
152 : _GLIBCXX_WRITE_MEM_BARRIER;
153 : }
154 :
155 : // Be race-detector-friendly. For more info see bits/c++config.
156 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
157 0 : if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
158 0 : -1) == 1)
159 : {
160 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
161 0 : _M_destroy();
162 0 : }
163 0 : }
164 12 : }
165 :
166 : void
167 : _M_weak_add_ref() noexcept
168 : { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
169 :
170 : void
171 : _M_weak_release() noexcept
172 : {
173 : // Be race-detector-friendly. For more info see bits/c++config.
174 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
175 : if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
176 : {
177 : _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
178 : if (_Mutex_base<_Lp>::_S_need_barriers)
179 : {
180 : // See _M_release(),
181 : // destroy() must observe results of dispose()
182 : _GLIBCXX_READ_MEM_BARRIER;
183 : _GLIBCXX_WRITE_MEM_BARRIER;
184 : }
185 : _M_destroy();
186 : }
187 : }
188 :
189 : long
190 : _M_get_use_count() const noexcept
191 : {
192 : // No memory barrier is used here so there is no synchronization
193 : // with other threads.
194 : return __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);
195 : }
196 :
197 : private:
198 : _Sp_counted_base(_Sp_counted_base const&) = delete;
199 : _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
200 :
201 : _Atomic_word _M_use_count; // #shared
202 : _Atomic_word _M_weak_count; // #weak + (#shared != 0)
203 : };
204 :
205 : template<>
206 : inline void
207 : _Sp_counted_base<_S_single>::
208 : _M_add_ref_lock()
209 : {
210 : if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
211 : {
212 : _M_use_count = 0;
213 : __throw_bad_weak_ptr();
214 : }
215 : }
216 :
217 : template<>
218 : inline void
219 : _Sp_counted_base<_S_mutex>::
220 : _M_add_ref_lock()
221 : {
222 : __gnu_cxx::__scoped_lock sentry(*this);
223 : if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
224 : {
225 : _M_use_count = 0;
226 : __throw_bad_weak_ptr();
227 : }
228 : }
229 :
230 : template<>
231 : inline void
232 : _Sp_counted_base<_S_atomic>::
233 : _M_add_ref_lock()
234 : {
235 : // Perform lock-free add-if-not-zero operation.
236 : _Atomic_word __count = _M_get_use_count();
237 : do
238 : {
239 : if (__count == 0)
240 : __throw_bad_weak_ptr();
241 : // Replace the current counter value with the old value + 1, as
242 : // long as it's not changed meanwhile.
243 : }
244 : while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
245 : true, __ATOMIC_ACQ_REL,
246 : __ATOMIC_RELAXED));
247 : }
248 :
249 :
250 : // Forward declarations.
251 : template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
252 : class __shared_ptr;
253 :
254 : template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
255 : class __weak_ptr;
256 :
257 : template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
258 : class __enable_shared_from_this;
259 :
260 : template<typename _Tp>
261 : class shared_ptr;
262 :
263 : template<typename _Tp>
264 : class weak_ptr;
265 :
266 : template<typename _Tp>
267 : struct owner_less;
268 :
269 : template<typename _Tp>
270 : class enable_shared_from_this;
271 :
272 : template<_Lock_policy _Lp = __default_lock_policy>
273 : class __weak_count;
274 :
275 : template<_Lock_policy _Lp = __default_lock_policy>
276 : class __shared_count;
277 :
278 :
279 : // Counted ptr with no deleter or allocator support
280 : template<typename _Ptr, _Lock_policy _Lp>
281 : class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
282 : {
283 : public:
284 : explicit
285 : _Sp_counted_ptr(_Ptr __p)
286 : : _M_ptr(__p) { }
287 :
288 : virtual void
289 : _M_dispose() noexcept
290 : { delete _M_ptr; }
291 :
292 : virtual void
293 : _M_destroy() noexcept
294 : { delete this; }
295 :
296 : virtual void*
297 : _M_get_deleter(const std::type_info&)
298 : { return 0; }
299 :
300 : _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
301 : _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
302 :
303 : protected:
304 : _Ptr _M_ptr; // copy constructor must not throw
305 : };
306 :
307 : template<>
308 : inline void
309 : _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
310 :
311 : template<>
312 : inline void
313 : _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
314 :
315 : template<>
316 : inline void
317 : _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
318 :
319 : // Support for custom deleter and/or allocator
320 : template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
321 : class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
322 : {
323 : // Helper class that stores the Deleter and also acts as an allocator.
324 : // Used to dispose of the owned pointer and the internal refcount
325 : // Requires that copies of _Alloc can free each other's memory.
326 12 : struct _My_Deleter
327 : : public _Alloc // copy constructor must not throw
328 : {
329 : _Deleter _M_del; // copy constructor must not throw
330 : _My_Deleter(_Deleter __d, const _Alloc& __a)
331 12 : : _Alloc(__a), _M_del(__d) { }
332 : };
333 :
334 : public:
335 : // __d(__p) must not throw.
336 : _Sp_counted_deleter(_Ptr __p, _Deleter __d)
337 : : _M_ptr(__p), _M_del(__d, _Alloc()) { }
338 :
339 : // __d(__p) must not throw.
340 12 : _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a)
341 36 : : _M_ptr(__p), _M_del(__d, __a) { }
342 :
343 12 : ~_Sp_counted_deleter() noexcept { }
344 :
345 : virtual void
346 : _M_dispose() noexcept
347 24 : { _M_del._M_del(_M_ptr); }
348 :
349 : virtual void
350 : _M_destroy() noexcept
351 : {
352 : typedef typename allocator_traits<_Alloc>::template
353 : rebind_traits<_Sp_counted_deleter> _Alloc_traits;
354 12 : typename _Alloc_traits::allocator_type __a(_M_del);
355 12 : _Alloc_traits::destroy(__a, this);
356 12 : _Alloc_traits::deallocate(__a, this, 1);
357 12 : }
358 :
359 : virtual void*
360 : _M_get_deleter(const std::type_info& __ti)
361 : {
362 : #ifdef __GXX_RTTI
363 : return __ti == typeid(_Deleter) ? &_M_del._M_del : 0;
364 : #else
365 0 : return 0;
366 : #endif
367 : }
368 :
369 : protected:
370 : _Ptr _M_ptr; // copy constructor must not throw
371 : _My_Deleter _M_del; // copy constructor must not throw
372 : };
373 :
374 : // helpers for make_shared / allocate_shared
375 :
376 : struct _Sp_make_shared_tag { };
377 :
378 : template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
379 : class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
380 : {
381 : // Helper class that stores the pointer and also acts as an allocator.
382 : // Used to dispose of the owned pointer and the internal refcount
383 : // Requires that copies of _Alloc can free each other's memory.
384 : struct _Impl
385 : : public _Alloc // copy constructor must not throw
386 : {
387 : _Impl(_Alloc __a) : _Alloc(__a), _M_ptr() { }
388 : _Tp* _M_ptr;
389 : };
390 :
391 : public:
392 : template<typename... _Args>
393 : _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
394 : : _M_impl(__a)
395 : {
396 : _M_impl._M_ptr = static_cast<_Tp*>(static_cast<void*>(&_M_storage));
397 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
398 : // 2070. allocate_shared should use allocator_traits<A>::construct
399 : allocator_traits<_Alloc>::construct(__a, _M_impl._M_ptr,
400 : std::forward<_Args>(__args)...); // might throw
401 : }
402 :
403 : ~_Sp_counted_ptr_inplace() noexcept { }
404 :
405 : virtual void
406 : _M_dispose() noexcept
407 : { allocator_traits<_Alloc>::destroy(_M_impl, _M_impl._M_ptr); }
408 :
409 : // Override because the allocator needs to know the dynamic type
410 : virtual void
411 : _M_destroy() noexcept
412 : {
413 : typedef typename allocator_traits<_Alloc>::template
414 : rebind_traits<_Sp_counted_ptr_inplace> _Alloc_traits;
415 : typename _Alloc_traits::allocator_type __a(_M_impl);
416 : _Alloc_traits::destroy(__a, this);
417 : _Alloc_traits::deallocate(__a, this, 1);
418 : }
419 :
420 : // Sneaky trick so __shared_ptr can get the managed pointer
421 : virtual void*
422 : _M_get_deleter(const std::type_info& __ti) noexcept
423 : {
424 : #ifdef __GXX_RTTI
425 : return __ti == typeid(_Sp_make_shared_tag)
426 : ? static_cast<void*>(&_M_storage)
427 : : 0;
428 : #else
429 : return 0;
430 : #endif
431 : }
432 :
433 : private:
434 : _Impl _M_impl;
435 : typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type
436 : _M_storage;
437 : };
438 :
439 : template<_Lock_policy _Lp>
440 : class __shared_count
441 : {
442 : public:
443 12 : constexpr __shared_count() noexcept : _M_pi(0)
444 12 : { }
445 :
446 : template<typename _Ptr>
447 : explicit
448 : __shared_count(_Ptr __p) : _M_pi(0)
449 : {
450 : __try
451 : {
452 : _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
453 : }
454 : __catch(...)
455 : {
456 : delete __p;
457 : __throw_exception_again;
458 : }
459 : }
460 :
461 : template<typename _Ptr, typename _Deleter>
462 : __shared_count(_Ptr __p, _Deleter __d)
463 : : __shared_count(__p, std::move(__d), allocator<int>())
464 : { }
465 :
466 : template<typename _Ptr, typename _Deleter, typename _Alloc>
467 12 : __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
468 : {
469 : typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
470 : typedef typename allocator_traits<_Alloc>::template
471 : rebind_traits<_Sp_cd_type> _Alloc_traits;
472 12 : typename _Alloc_traits::allocator_type __a2(__a);
473 12 : _Sp_cd_type* __mem = 0;
474 : __try
475 : {
476 24 : __mem = _Alloc_traits::allocate(__a2, 1);
477 24 : _Alloc_traits::construct(__a2, __mem,
478 12 : __p, std::move(__d), std::move(__a));
479 12 : _M_pi = __mem;
480 12 : }
481 : __catch(...)
482 : {
483 0 : __d(__p); // Call _Deleter on __p.
484 0 : if (__mem)
485 0 : _Alloc_traits::deallocate(__a2, __mem, 1);
486 0 : __throw_exception_again;
487 0 : }
488 12 : }
489 :
490 : template<typename _Tp, typename _Alloc, typename... _Args>
491 : __shared_count(_Sp_make_shared_tag, _Tp*, const _Alloc& __a,
492 : _Args&&... __args)
493 : : _M_pi(0)
494 : {
495 : typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
496 : typedef typename allocator_traits<_Alloc>::template
497 : rebind_traits<_Sp_cp_type> _Alloc_traits;
498 : typename _Alloc_traits::allocator_type __a2(__a);
499 : _Sp_cp_type* __mem = _Alloc_traits::allocate(__a2, 1);
500 : __try
501 : {
502 : _Alloc_traits::construct(__a2, __mem, std::move(__a),
503 : std::forward<_Args>(__args)...);
504 : _M_pi = __mem;
505 : }
506 : __catch(...)
507 : {
508 : _Alloc_traits::deallocate(__a2, __mem, 1);
509 : __throw_exception_again;
510 : }
511 : }
512 :
513 : #if _GLIBCXX_USE_DEPRECATED
514 : // Special case for auto_ptr<_Tp> to provide the strong guarantee.
515 : template<typename _Tp>
516 : explicit
517 : __shared_count(std::auto_ptr<_Tp>&& __r);
518 : #endif
519 :
520 : // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
521 : template<typename _Tp, typename _Del>
522 : explicit
523 : __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
524 : {
525 : using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
526 : using _Del2 = typename conditional<is_reference<_Del>::value,
527 : reference_wrapper<typename remove_reference<_Del>::type>,
528 : _Del>::type;
529 : using _Sp_cd_type
530 : = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
531 : using _Alloc = allocator<_Sp_cd_type>;
532 : using _Alloc_traits = allocator_traits<_Alloc>;
533 : _Alloc __a;
534 : _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
535 : _Alloc_traits::construct(__a, __mem, __r.release(),
536 : __r.get_deleter()); // non-throwing
537 : _M_pi = __mem;
538 : }
539 :
540 : // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
541 : explicit __shared_count(const __weak_count<_Lp>& __r);
542 :
543 : ~__shared_count() noexcept
544 : {
545 24 : if (_M_pi != nullptr)
546 12 : _M_pi->_M_release();
547 24 : }
548 :
549 : __shared_count(const __shared_count& __r) noexcept
550 : : _M_pi(__r._M_pi)
551 : {
552 : if (_M_pi != 0)
553 : _M_pi->_M_add_ref_copy();
554 : }
555 :
556 : __shared_count&
557 : operator=(const __shared_count& __r) noexcept
558 : {
559 : _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
560 : if (__tmp != _M_pi)
561 : {
562 : if (__tmp != 0)
563 : __tmp->_M_add_ref_copy();
564 : if (_M_pi != 0)
565 : _M_pi->_M_release();
566 : _M_pi = __tmp;
567 : }
568 : return *this;
569 : }
570 :
571 : void
572 : _M_swap(__shared_count& __r) noexcept
573 : {
574 12 : _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
575 12 : __r._M_pi = _M_pi;
576 12 : _M_pi = __tmp;
577 12 : }
578 :
579 : long
580 : _M_get_use_count() const noexcept
581 : { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
582 :
583 : bool
584 : _M_unique() const noexcept
585 : { return this->_M_get_use_count() == 1; }
586 :
587 : void*
588 : _M_get_deleter(const std::type_info& __ti) const noexcept
589 : { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; }
590 :
591 : bool
592 : _M_less(const __shared_count& __rhs) const noexcept
593 : { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
594 :
595 : bool
596 : _M_less(const __weak_count<_Lp>& __rhs) const noexcept
597 : { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
598 :
599 : // Friend function injected into enclosing namespace and found by ADL
600 : friend inline bool
601 : operator==(const __shared_count& __a, const __shared_count& __b) noexcept
602 : { return __a._M_pi == __b._M_pi; }
603 :
604 : private:
605 : friend class __weak_count<_Lp>;
606 :
607 : _Sp_counted_base<_Lp>* _M_pi;
608 : };
609 :
610 :
611 : template<_Lock_policy _Lp>
612 : class __weak_count
613 : {
614 : public:
615 : constexpr __weak_count() noexcept : _M_pi(0)
616 : { }
617 :
618 : __weak_count(const __shared_count<_Lp>& __r) noexcept
619 : : _M_pi(__r._M_pi)
620 : {
621 : if (_M_pi != 0)
622 : _M_pi->_M_weak_add_ref();
623 : }
624 :
625 : __weak_count(const __weak_count<_Lp>& __r) noexcept
626 : : _M_pi(__r._M_pi)
627 : {
628 : if (_M_pi != 0)
629 : _M_pi->_M_weak_add_ref();
630 : }
631 :
632 : ~__weak_count() noexcept
633 : {
634 : if (_M_pi != 0)
635 : _M_pi->_M_weak_release();
636 : }
637 :
638 : __weak_count<_Lp>&
639 : operator=(const __shared_count<_Lp>& __r) noexcept
640 : {
641 : _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
642 : if (__tmp != 0)
643 : __tmp->_M_weak_add_ref();
644 : if (_M_pi != 0)
645 : _M_pi->_M_weak_release();
646 : _M_pi = __tmp;
647 : return *this;
648 : }
649 :
650 : __weak_count<_Lp>&
651 : operator=(const __weak_count<_Lp>& __r) noexcept
652 : {
653 : _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
654 : if (__tmp != 0)
655 : __tmp->_M_weak_add_ref();
656 : if (_M_pi != 0)
657 : _M_pi->_M_weak_release();
658 : _M_pi = __tmp;
659 : return *this;
660 : }
661 :
662 : void
663 : _M_swap(__weak_count<_Lp>& __r) noexcept
664 : {
665 : _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
666 : __r._M_pi = _M_pi;
667 : _M_pi = __tmp;
668 : }
669 :
670 : long
671 : _M_get_use_count() const noexcept
672 : { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
673 :
674 : bool
675 : _M_less(const __weak_count& __rhs) const noexcept
676 : { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
677 :
678 : bool
679 : _M_less(const __shared_count<_Lp>& __rhs) const noexcept
680 : { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
681 :
682 : // Friend function injected into enclosing namespace and found by ADL
683 : friend inline bool
684 : operator==(const __weak_count& __a, const __weak_count& __b) noexcept
685 : { return __a._M_pi == __b._M_pi; }
686 :
687 : private:
688 : friend class __shared_count<_Lp>;
689 :
690 : _Sp_counted_base<_Lp>* _M_pi;
691 : };
692 :
693 : // Now that __weak_count is defined we can define this constructor:
694 : template<_Lock_policy _Lp>
695 : inline __shared_count<_Lp>:: __shared_count(const __weak_count<_Lp>& __r)
696 : : _M_pi(__r._M_pi)
697 : {
698 : if (_M_pi != 0)
699 : _M_pi->_M_add_ref_lock();
700 : else
701 : __throw_bad_weak_ptr();
702 : }
703 :
704 :
705 : // Support for enable_shared_from_this.
706 :
707 : // Friend of __enable_shared_from_this.
708 : template<_Lock_policy _Lp, typename _Tp1, typename _Tp2>
709 : void
710 : __enable_shared_from_this_helper(const __shared_count<_Lp>&,
711 : const __enable_shared_from_this<_Tp1,
712 : _Lp>*, const _Tp2*) noexcept;
713 :
714 : // Friend of enable_shared_from_this.
715 : template<typename _Tp1, typename _Tp2>
716 : void
717 : __enable_shared_from_this_helper(const __shared_count<>&,
718 : const enable_shared_from_this<_Tp1>*,
719 : const _Tp2*) noexcept;
720 :
721 : template<_Lock_policy _Lp>
722 : inline void
723 : __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) noexcept
724 12 : { }
725 :
726 :
727 : template<typename _Tp, _Lock_policy _Lp>
728 : class __shared_ptr
729 : {
730 : public:
731 : typedef _Tp element_type;
732 :
733 : constexpr __shared_ptr() noexcept
734 : : _M_ptr(0), _M_refcount()
735 : { }
736 :
737 : template<typename _Tp1>
738 : explicit __shared_ptr(_Tp1* __p)
739 : : _M_ptr(__p), _M_refcount(__p)
740 : {
741 : __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
742 : static_assert( sizeof(_Tp1) > 0, "incomplete type" );
743 : __enable_shared_from_this_helper(_M_refcount, __p, __p);
744 : }
745 :
746 : template<typename _Tp1, typename _Deleter>
747 : __shared_ptr(_Tp1* __p, _Deleter __d)
748 : : _M_ptr(__p), _M_refcount(__p, __d)
749 : {
750 : __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
751 : // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
752 : __enable_shared_from_this_helper(_M_refcount, __p, __p);
753 : }
754 :
755 : template<typename _Tp1, typename _Deleter, typename _Alloc>
756 : __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
757 : : _M_ptr(__p), _M_refcount(__p, __d, std::move(__a))
758 : {
759 : __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
760 : // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
761 : __enable_shared_from_this_helper(_M_refcount, __p, __p);
762 : }
763 :
764 : template<typename _Deleter>
765 : __shared_ptr(nullptr_t __p, _Deleter __d)
766 : : _M_ptr(0), _M_refcount(__p, __d)
767 : { }
768 :
769 : template<typename _Deleter, typename _Alloc>
770 : __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
771 : : _M_ptr(0), _M_refcount(__p, __d, std::move(__a))
772 : { }
773 :
774 : template<typename _Tp1>
775 : __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) noexcept
776 : : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
777 : { }
778 :
779 : __shared_ptr(const __shared_ptr&) noexcept = default;
780 : __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
781 12 : ~__shared_ptr() = default;
782 :
783 : template<typename _Tp1, typename = typename
784 : std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
785 : __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
786 : : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
787 : { }
788 :
789 : __shared_ptr(__shared_ptr&& __r) noexcept
790 : : _M_ptr(__r._M_ptr), _M_refcount()
791 : {
792 : _M_refcount._M_swap(__r._M_refcount);
793 : __r._M_ptr = 0;
794 : }
795 :
796 : template<typename _Tp1, typename = typename
797 : std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
798 : __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
799 : : _M_ptr(__r._M_ptr), _M_refcount()
800 : {
801 : _M_refcount._M_swap(__r._M_refcount);
802 : __r._M_ptr = 0;
803 : }
804 :
805 : template<typename _Tp1>
806 : explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
807 : : _M_refcount(__r._M_refcount) // may throw
808 : {
809 : __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
810 :
811 : // It is now safe to copy __r._M_ptr, as
812 : // _M_refcount(__r._M_refcount) did not throw.
813 : _M_ptr = __r._M_ptr;
814 : }
815 :
816 : // If an exception is thrown this constructor has no effect.
817 : template<typename _Tp1, typename _Del>
818 : __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
819 : : _M_ptr(__r.get()), _M_refcount()
820 : {
821 : __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
822 : auto __tmp = __r.get();
823 : _M_refcount = __shared_count<_Lp>(std::move(__r));
824 : __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
825 : }
826 :
827 : #if _GLIBCXX_USE_DEPRECATED
828 : // Postcondition: use_count() == 1 and __r.get() == 0
829 : template<typename _Tp1>
830 : __shared_ptr(std::auto_ptr<_Tp1>&& __r);
831 : #endif
832 :
833 : /* TODO: use delegating constructor */
834 : constexpr __shared_ptr(nullptr_t) noexcept
835 : : _M_ptr(0), _M_refcount()
836 : { }
837 :
838 : template<typename _Tp1>
839 : __shared_ptr&
840 : operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
841 : {
842 : _M_ptr = __r._M_ptr;
843 : _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
844 : return *this;
845 : }
846 :
847 : #if _GLIBCXX_USE_DEPRECATED
848 : template<typename _Tp1>
849 : __shared_ptr&
850 : operator=(std::auto_ptr<_Tp1>&& __r)
851 : {
852 : __shared_ptr(std::move(__r)).swap(*this);
853 : return *this;
854 : }
855 : #endif
856 :
857 : __shared_ptr&
858 : operator=(__shared_ptr&& __r) noexcept
859 : {
860 : __shared_ptr(std::move(__r)).swap(*this);
861 : return *this;
862 : }
863 :
864 : template<class _Tp1>
865 : __shared_ptr&
866 : operator=(__shared_ptr<_Tp1, _Lp>&& __r) noexcept
867 : {
868 : __shared_ptr(std::move(__r)).swap(*this);
869 : return *this;
870 : }
871 :
872 : template<typename _Tp1, typename _Del>
873 : __shared_ptr&
874 : operator=(std::unique_ptr<_Tp1, _Del>&& __r)
875 : {
876 : __shared_ptr(std::move(__r)).swap(*this);
877 : return *this;
878 : }
879 :
880 : void
881 : reset() noexcept
882 : { __shared_ptr().swap(*this); }
883 :
884 : template<typename _Tp1>
885 : void
886 : reset(_Tp1* __p) // _Tp1 must be complete.
887 : {
888 : // Catch self-reset errors.
889 : _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr);
890 : __shared_ptr(__p).swap(*this);
891 : }
892 :
893 : template<typename _Tp1, typename _Deleter>
894 : void
895 : reset(_Tp1* __p, _Deleter __d)
896 : { __shared_ptr(__p, __d).swap(*this); }
897 :
898 : template<typename _Tp1, typename _Deleter, typename _Alloc>
899 : void
900 : reset(_Tp1* __p, _Deleter __d, _Alloc __a)
901 : { __shared_ptr(__p, __d, std::move(__a)).swap(*this); }
902 :
903 : // Allow class instantiation when _Tp is [cv-qual] void.
904 : typename std::add_lvalue_reference<_Tp>::type
905 : operator*() const noexcept
906 : {
907 : _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
908 : return *_M_ptr;
909 : }
910 :
911 : _Tp*
912 : operator->() const noexcept
913 : {
914 : _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0);
915 : return _M_ptr;
916 : }
917 :
918 : _Tp*
919 : get() const noexcept
920 : { return _M_ptr; }
921 :
922 : explicit operator bool() const // never throws
923 : { return _M_ptr == 0 ? false : true; }
924 :
925 : bool
926 : unique() const noexcept
927 : { return _M_refcount._M_unique(); }
928 :
929 : long
930 : use_count() const noexcept
931 : { return _M_refcount._M_get_use_count(); }
932 :
933 : void
934 : swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
935 : {
936 : std::swap(_M_ptr, __other._M_ptr);
937 : _M_refcount._M_swap(__other._M_refcount);
938 : }
939 :
940 : template<typename _Tp1>
941 : bool
942 : owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
943 : { return _M_refcount._M_less(__rhs._M_refcount); }
944 :
945 : template<typename _Tp1>
946 : bool
947 : owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
948 : { return _M_refcount._M_less(__rhs._M_refcount); }
949 :
950 : #ifdef __GXX_RTTI
951 : protected:
952 : // This constructor is non-standard, it is used by allocate_shared.
953 : template<typename _Alloc, typename... _Args>
954 : __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
955 : _Args&&... __args)
956 : : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
957 : std::forward<_Args>(__args)...)
958 : {
959 : // _M_ptr needs to point to the newly constructed object.
960 : // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
961 : void* __p = _M_refcount._M_get_deleter(typeid(__tag));
962 : _M_ptr = static_cast<_Tp*>(__p);
963 : __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
964 : }
965 : #else
966 : template<typename _Alloc>
967 108 : struct _Deleter
968 : {
969 : void operator()(_Tp* __ptr)
970 : {
971 : typedef allocator_traits<_Alloc> _Alloc_traits;
972 12 : _Alloc_traits::destroy(_M_alloc, __ptr);
973 12 : _Alloc_traits::deallocate(_M_alloc, __ptr, 1);
974 12 : }
975 : _Alloc _M_alloc;
976 : };
977 :
978 : template<typename _Alloc, typename... _Args>
979 : __shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a,
980 : _Args&&... __args)
981 12 : : _M_ptr(), _M_refcount()
982 : {
983 : typedef typename _Alloc::template rebind<_Tp>::other _Alloc2;
984 12 : _Deleter<_Alloc2> __del = { _Alloc2(__a) };
985 : typedef allocator_traits<_Alloc2> __traits;
986 24 : _M_ptr = __traits::allocate(__del._M_alloc, 1);
987 : __try
988 : {
989 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
990 : // 2070. allocate_shared should use allocator_traits<A>::construct
991 12 : __traits::construct(__del._M_alloc, _M_ptr,
992 : std::forward<_Args>(__args)...);
993 12 : }
994 : __catch(...)
995 : {
996 0 : __traits::deallocate(__del._M_alloc, _M_ptr, 1);
997 0 : __throw_exception_again;
998 0 : }
999 24 : __shared_count<_Lp> __count(_M_ptr, __del, __del._M_alloc);
1000 12 : _M_refcount._M_swap(__count);
1001 12 : __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
1002 12 : }
1003 : #endif
1004 :
1005 : template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
1006 : typename... _Args>
1007 : friend __shared_ptr<_Tp1, _Lp1>
1008 : __allocate_shared(const _Alloc& __a, _Args&&... __args);
1009 :
1010 : private:
1011 : void*
1012 : _M_get_deleter(const std::type_info& __ti) const noexcept
1013 : { return _M_refcount._M_get_deleter(__ti); }
1014 :
1015 : template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
1016 : template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
1017 :
1018 : template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
1019 : friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
1020 :
1021 : _Tp* _M_ptr; // Contained pointer.
1022 : __shared_count<_Lp> _M_refcount; // Reference counter.
1023 : };
1024 :
1025 :
1026 : // 20.7.2.2.7 shared_ptr comparisons
1027 : template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1028 : inline bool
1029 : operator==(const __shared_ptr<_Tp1, _Lp>& __a,
1030 : const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1031 : { return __a.get() == __b.get(); }
1032 :
1033 : template<typename _Tp, _Lock_policy _Lp>
1034 : inline bool
1035 : operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1036 : { return !__a; }
1037 :
1038 : template<typename _Tp, _Lock_policy _Lp>
1039 : inline bool
1040 : operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1041 : { return !__a; }
1042 :
1043 : template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1044 : inline bool
1045 : operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
1046 : const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1047 : { return __a.get() != __b.get(); }
1048 :
1049 : template<typename _Tp, _Lock_policy _Lp>
1050 : inline bool
1051 : operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1052 : { return (bool)__a; }
1053 :
1054 : template<typename _Tp, _Lock_policy _Lp>
1055 : inline bool
1056 : operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1057 : { return (bool)__a; }
1058 :
1059 : template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1060 : inline bool
1061 : operator<(const __shared_ptr<_Tp1, _Lp>& __a,
1062 : const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1063 : {
1064 : typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT;
1065 : return std::less<_CT>()(__a.get(), __b.get());
1066 : }
1067 :
1068 : template<typename _Tp, _Lock_policy _Lp>
1069 : inline bool
1070 : operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1071 : { return std::less<_Tp*>()(__a.get(), nullptr); }
1072 :
1073 : template<typename _Tp, _Lock_policy _Lp>
1074 : inline bool
1075 : operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1076 : { return std::less<_Tp*>()(nullptr, __a.get()); }
1077 :
1078 : template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1079 : inline bool
1080 : operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
1081 : const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1082 : { return !(__b < __a); }
1083 :
1084 : template<typename _Tp, _Lock_policy _Lp>
1085 : inline bool
1086 : operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1087 : { return !(nullptr < __a); }
1088 :
1089 : template<typename _Tp, _Lock_policy _Lp>
1090 : inline bool
1091 : operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1092 : { return !(__a < nullptr); }
1093 :
1094 : template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1095 : inline bool
1096 : operator>(const __shared_ptr<_Tp1, _Lp>& __a,
1097 : const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1098 : { return (__b < __a); }
1099 :
1100 : template<typename _Tp, _Lock_policy _Lp>
1101 : inline bool
1102 : operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1103 : { return std::less<_Tp*>()(nullptr, __a.get()); }
1104 :
1105 : template<typename _Tp, _Lock_policy _Lp>
1106 : inline bool
1107 : operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1108 : { return std::less<_Tp*>()(__a.get(), nullptr); }
1109 :
1110 : template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1111 : inline bool
1112 : operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
1113 : const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1114 : { return !(__a < __b); }
1115 :
1116 : template<typename _Tp, _Lock_policy _Lp>
1117 : inline bool
1118 : operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1119 : { return !(__a < nullptr); }
1120 :
1121 : template<typename _Tp, _Lock_policy _Lp>
1122 : inline bool
1123 : operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1124 : { return !(nullptr < __a); }
1125 :
1126 : template<typename _Sp>
1127 : struct _Sp_less : public binary_function<_Sp, _Sp, bool>
1128 : {
1129 : bool
1130 : operator()(const _Sp& __lhs, const _Sp& __rhs) const noexcept
1131 : {
1132 : typedef typename _Sp::element_type element_type;
1133 : return std::less<element_type*>()(__lhs.get(), __rhs.get());
1134 : }
1135 : };
1136 :
1137 : template<typename _Tp, _Lock_policy _Lp>
1138 : struct less<__shared_ptr<_Tp, _Lp>>
1139 : : public _Sp_less<__shared_ptr<_Tp, _Lp>>
1140 : { };
1141 :
1142 : // 2.2.3.8 shared_ptr specialized algorithms.
1143 : template<typename _Tp, _Lock_policy _Lp>
1144 : inline void
1145 : swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
1146 : { __a.swap(__b); }
1147 :
1148 : // 2.2.3.9 shared_ptr casts
1149 :
1150 : // The seemingly equivalent code:
1151 : // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
1152 : // will eventually result in undefined behaviour, attempting to
1153 : // delete the same object twice.
1154 : /// static_pointer_cast
1155 : template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
1156 : inline __shared_ptr<_Tp, _Lp>
1157 : static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
1158 : { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
1159 :
1160 : // The seemingly equivalent code:
1161 : // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
1162 : // will eventually result in undefined behaviour, attempting to
1163 : // delete the same object twice.
1164 : /// const_pointer_cast
1165 : template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
1166 : inline __shared_ptr<_Tp, _Lp>
1167 : const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
1168 : { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
1169 :
1170 : // The seemingly equivalent code:
1171 : // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
1172 : // will eventually result in undefined behaviour, attempting to
1173 : // delete the same object twice.
1174 : /// dynamic_pointer_cast
1175 : template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
1176 : inline __shared_ptr<_Tp, _Lp>
1177 : dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
1178 : {
1179 : if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
1180 : return __shared_ptr<_Tp, _Lp>(__r, __p);
1181 : return __shared_ptr<_Tp, _Lp>();
1182 : }
1183 :
1184 :
1185 : template<typename _Tp, _Lock_policy _Lp>
1186 : class __weak_ptr
1187 : {
1188 : public:
1189 : typedef _Tp element_type;
1190 :
1191 : constexpr __weak_ptr() noexcept
1192 : : _M_ptr(0), _M_refcount()
1193 : { }
1194 :
1195 : __weak_ptr(const __weak_ptr&) noexcept = default;
1196 : __weak_ptr& operator=(const __weak_ptr&) noexcept = default;
1197 : ~__weak_ptr() = default;
1198 :
1199 : // The "obvious" converting constructor implementation:
1200 : //
1201 : // template<typename _Tp1>
1202 : // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
1203 : // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
1204 : // { }
1205 : //
1206 : // has a serious problem.
1207 : //
1208 : // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
1209 : // conversion may require access to *__r._M_ptr (virtual inheritance).
1210 : //
1211 : // It is not possible to avoid spurious access violations since
1212 : // in multithreaded programs __r._M_ptr may be invalidated at any point.
1213 : template<typename _Tp1, typename = typename
1214 : std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
1215 : __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
1216 : : _M_refcount(__r._M_refcount)
1217 : { _M_ptr = __r.lock().get(); }
1218 :
1219 : template<typename _Tp1, typename = typename
1220 : std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
1221 : __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
1222 : : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
1223 : { }
1224 :
1225 : template<typename _Tp1>
1226 : __weak_ptr&
1227 : operator=(const __weak_ptr<_Tp1, _Lp>& __r) noexcept
1228 : {
1229 : _M_ptr = __r.lock().get();
1230 : _M_refcount = __r._M_refcount;
1231 : return *this;
1232 : }
1233 :
1234 : template<typename _Tp1>
1235 : __weak_ptr&
1236 : operator=(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
1237 : {
1238 : _M_ptr = __r._M_ptr;
1239 : _M_refcount = __r._M_refcount;
1240 : return *this;
1241 : }
1242 :
1243 : __shared_ptr<_Tp, _Lp>
1244 : lock() const noexcept
1245 : {
1246 : #ifdef __GTHREADS
1247 : // Optimization: avoid throw overhead.
1248 : if (expired())
1249 : return __shared_ptr<element_type, _Lp>();
1250 :
1251 : __try
1252 : {
1253 : return __shared_ptr<element_type, _Lp>(*this);
1254 : }
1255 : __catch(const bad_weak_ptr&)
1256 : {
1257 : // Q: How can we get here?
1258 : // A: Another thread may have invalidated r after the
1259 : // use_count test above.
1260 : return __shared_ptr<element_type, _Lp>();
1261 : }
1262 :
1263 : #else
1264 : // Optimization: avoid try/catch overhead when single threaded.
1265 : return expired() ? __shared_ptr<element_type, _Lp>()
1266 : : __shared_ptr<element_type, _Lp>(*this);
1267 :
1268 : #endif
1269 : } // XXX MT
1270 :
1271 : long
1272 : use_count() const noexcept
1273 : { return _M_refcount._M_get_use_count(); }
1274 :
1275 : bool
1276 : expired() const noexcept
1277 : { return _M_refcount._M_get_use_count() == 0; }
1278 :
1279 : template<typename _Tp1>
1280 : bool
1281 : owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
1282 : { return _M_refcount._M_less(__rhs._M_refcount); }
1283 :
1284 : template<typename _Tp1>
1285 : bool
1286 : owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
1287 : { return _M_refcount._M_less(__rhs._M_refcount); }
1288 :
1289 : void
1290 : reset() noexcept
1291 : { __weak_ptr().swap(*this); }
1292 :
1293 : void
1294 : swap(__weak_ptr& __s) noexcept
1295 : {
1296 : std::swap(_M_ptr, __s._M_ptr);
1297 : _M_refcount._M_swap(__s._M_refcount);
1298 : }
1299 :
1300 : private:
1301 : // Used by __enable_shared_from_this.
1302 : void
1303 : _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
1304 : {
1305 : _M_ptr = __ptr;
1306 : _M_refcount = __refcount;
1307 : }
1308 :
1309 : template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
1310 : template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
1311 : friend class __enable_shared_from_this<_Tp, _Lp>;
1312 : friend class enable_shared_from_this<_Tp>;
1313 :
1314 : _Tp* _M_ptr; // Contained pointer.
1315 : __weak_count<_Lp> _M_refcount; // Reference counter.
1316 : };
1317 :
1318 : // 20.7.2.3.6 weak_ptr specialized algorithms.
1319 : template<typename _Tp, _Lock_policy _Lp>
1320 : inline void
1321 : swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
1322 : { __a.swap(__b); }
1323 :
1324 : template<typename _Tp, typename _Tp1>
1325 : struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
1326 : {
1327 : bool
1328 : operator()(const _Tp& __lhs, const _Tp& __rhs) const
1329 : { return __lhs.owner_before(__rhs); }
1330 :
1331 : bool
1332 : operator()(const _Tp& __lhs, const _Tp1& __rhs) const
1333 : { return __lhs.owner_before(__rhs); }
1334 :
1335 : bool
1336 : operator()(const _Tp1& __lhs, const _Tp& __rhs) const
1337 : { return __lhs.owner_before(__rhs); }
1338 : };
1339 :
1340 : template<typename _Tp, _Lock_policy _Lp>
1341 : struct owner_less<__shared_ptr<_Tp, _Lp>>
1342 : : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
1343 : { };
1344 :
1345 : template<typename _Tp, _Lock_policy _Lp>
1346 : struct owner_less<__weak_ptr<_Tp, _Lp>>
1347 : : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
1348 : { };
1349 :
1350 :
1351 : template<typename _Tp, _Lock_policy _Lp>
1352 : class __enable_shared_from_this
1353 : {
1354 : protected:
1355 : constexpr __enable_shared_from_this() noexcept { }
1356 :
1357 : __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
1358 :
1359 : __enable_shared_from_this&
1360 : operator=(const __enable_shared_from_this&) noexcept
1361 : { return *this; }
1362 :
1363 : ~__enable_shared_from_this() { }
1364 :
1365 : public:
1366 : __shared_ptr<_Tp, _Lp>
1367 : shared_from_this()
1368 : { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
1369 :
1370 : __shared_ptr<const _Tp, _Lp>
1371 : shared_from_this() const
1372 : { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
1373 :
1374 : private:
1375 : template<typename _Tp1>
1376 : void
1377 : _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
1378 : { _M_weak_this._M_assign(__p, __n); }
1379 :
1380 : template<typename _Tp1>
1381 : friend void
1382 : __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
1383 : const __enable_shared_from_this* __pe,
1384 : const _Tp1* __px) noexcept
1385 : {
1386 : if (__pe != 0)
1387 : __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1388 : }
1389 :
1390 : mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
1391 : };
1392 :
1393 :
1394 : template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
1395 : inline __shared_ptr<_Tp, _Lp>
1396 : __allocate_shared(const _Alloc& __a, _Args&&... __args)
1397 : {
1398 : return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), __a,
1399 : std::forward<_Args>(__args)...);
1400 : }
1401 :
1402 : template<typename _Tp, _Lock_policy _Lp, typename... _Args>
1403 : inline __shared_ptr<_Tp, _Lp>
1404 : __make_shared(_Args&&... __args)
1405 : {
1406 : typedef typename std::remove_const<_Tp>::type _Tp_nc;
1407 : return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
1408 : std::forward<_Args>(__args)...);
1409 : }
1410 :
1411 : /// std::hash specialization for __shared_ptr.
1412 : template<typename _Tp, _Lock_policy _Lp>
1413 : struct hash<__shared_ptr<_Tp, _Lp>>
1414 : : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
1415 : {
1416 : size_t
1417 : operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
1418 : { return std::hash<_Tp*>()(__s.get()); }
1419 : };
1420 :
1421 : _GLIBCXX_END_NAMESPACE_VERSION
1422 : } // namespace
1423 :
1424 : #endif // _SHARED_PTR_BASE_H
|
