1// <tr1/shared_ptr.h> -*- C++ -*- 2 3// Copyright (C) 2007-2014 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// shared_count.hpp 26// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. 27 28// shared_ptr.hpp 29// Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes. 30// Copyright (C) 2001, 2002, 2003 Peter Dimov 31 32// weak_ptr.hpp 33// Copyright (C) 2001, 2002, 2003 Peter Dimov 34 35// enable_shared_from_this.hpp 36// Copyright (C) 2002 Peter Dimov 37 38// Distributed under the Boost Software License, Version 1.0. (See 39// accompanying file LICENSE_1_0.txt or copy at 40// http://www.boost.org/LICENSE_1_0.txt) 41 42// GCC Note: based on version 1.32.0 of the Boost library. 43 44/** @file tr1/shared_ptr.h 45 * This is an internal header file, included by other library headers. 46 * Do not attempt to use it directly. @headername{tr1/memory} 47 */ 48 49#ifndef _TR1_SHARED_PTR_H 50#define _TR1_SHARED_PTR_H 1 51 52namespace std _GLIBCXX_VISIBILITY(default) 53{ 54namespace tr1 55{ 56_GLIBCXX_BEGIN_NAMESPACE_VERSION 57 58 /** 59 * @brief Exception possibly thrown by @c shared_ptr. 60 * @ingroup exceptions 61 */ 62 class bad_weak_ptr : public std::exception 63 { 64 public: 65 virtual char const* 66 what() const throw() 67 { return "tr1::bad_weak_ptr"; } 68 }; 69 70 // Substitute for bad_weak_ptr object in the case of -fno-exceptions. 71 inline void 72 __throw_bad_weak_ptr() 73 { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); } 74 75 using __gnu_cxx::_Lock_policy; 76 using __gnu_cxx::__default_lock_policy; 77 using __gnu_cxx::_S_single; 78 using __gnu_cxx::_S_mutex; 79 using __gnu_cxx::_S_atomic; 80 81 // Empty helper class except when the template argument is _S_mutex. 82 template<_Lock_policy _Lp> 83 class _Mutex_base 84 { 85 protected: 86 // The atomic policy uses fully-fenced builtins, single doesn't care. 87 enum { _S_need_barriers = 0 }; 88 }; 89 90 template<> 91 class _Mutex_base<_S_mutex> 92 : public __gnu_cxx::__mutex 93 { 94 protected: 95 // This policy is used when atomic builtins are not available. 96 // The replacement atomic operations might not have the necessary 97 // memory barriers. 98 enum { _S_need_barriers = 1 }; 99 }; 100 101 template<_Lock_policy _Lp = __default_lock_policy> 102 class _Sp_counted_base 103 : public _Mutex_base<_Lp> 104 { 105 public: 106 _Sp_counted_base() 107 : _M_use_count(1), _M_weak_count(1) { } 108 109 virtual 110 ~_Sp_counted_base() // nothrow 111 { } 112 113 // Called when _M_use_count drops to zero, to release the resources 114 // managed by *this. 115 virtual void 116 _M_dispose() = 0; // nothrow 117 118 // Called when _M_weak_count drops to zero. 119 virtual void 120 _M_destroy() // nothrow 121 { delete this; } 122 123 virtual void* 124 _M_get_deleter(const std::type_info&) = 0; 125 126 void 127 _M_add_ref_copy() 128 { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } 129 130 void 131 _M_add_ref_lock(); 132 133 void 134 _M_release() // nothrow 135 { 136 // Be race-detector-friendly. For more info see bits/c++config. 137 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count); 138 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) 139 { 140 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count); 141 _M_dispose(); 142 // There must be a memory barrier between dispose() and destroy() 143 // to ensure that the effects of dispose() are observed in the 144 // thread that runs destroy(). 145 // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html 146 if (_Mutex_base<_Lp>::_S_need_barriers) 147 { 148 _GLIBCXX_READ_MEM_BARRIER; 149 _GLIBCXX_WRITE_MEM_BARRIER; 150 } 151 152 // Be race-detector-friendly. For more info see bits/c++config. 153 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); 154 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, 155 -1) == 1) 156 { 157 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); 158 _M_destroy(); 159 } 160 } 161 } 162 163 void 164 _M_weak_add_ref() // nothrow 165 { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } 166 167 void 168 _M_weak_release() // nothrow 169 { 170 // Be race-detector-friendly. For more info see bits/c++config. 171 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count); 172 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) 173 { 174 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count); 175 if (_Mutex_base<_Lp>::_S_need_barriers) 176 { 177 // See _M_release(), 178 // destroy() must observe results of dispose() 179 _GLIBCXX_READ_MEM_BARRIER; 180 _GLIBCXX_WRITE_MEM_BARRIER; 181 } 182 _M_destroy(); 183 } 184 } 185 186 long 187 _M_get_use_count() const // nothrow 188 { 189 // No memory barrier is used here so there is no synchronization 190 // with other threads. 191 return const_cast<const volatile _Atomic_word&>(_M_use_count); 192 } 193 194 private: 195 _Sp_counted_base(_Sp_counted_base const&); 196 _Sp_counted_base& operator=(_Sp_counted_base const&); 197 198 _Atomic_word _M_use_count; // #shared 199 _Atomic_word _M_weak_count; // #weak + (#shared != 0) 200 }; 201 202 template<> 203 inline void 204 _Sp_counted_base<_S_single>:: 205 _M_add_ref_lock() 206 { 207 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) 208 { 209 _M_use_count = 0; 210 __throw_bad_weak_ptr(); 211 } 212 } 213 214 template<> 215 inline void 216 _Sp_counted_base<_S_mutex>:: 217 _M_add_ref_lock() 218 { 219 __gnu_cxx::__scoped_lock sentry(*this); 220 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) 221 { 222 _M_use_count = 0; 223 __throw_bad_weak_ptr(); 224 } 225 } 226 227 template<> 228 inline void 229 _Sp_counted_base<_S_atomic>:: 230 _M_add_ref_lock() 231 { 232 // Perform lock-free add-if-not-zero operation. 233 _Atomic_word __count = _M_use_count; 234 do 235 { 236 if (__count == 0) 237 __throw_bad_weak_ptr(); 238 // Replace the current counter value with the old value + 1, as 239 // long as it's not changed meanwhile. 240 } 241 while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, 242 true, __ATOMIC_ACQ_REL, 243 __ATOMIC_RELAXED)); 244 } 245 246 template<typename _Ptr, typename _Deleter, _Lock_policy _Lp> 247 class _Sp_counted_base_impl 248 : public _Sp_counted_base<_Lp> 249 { 250 public: 251 // Precondition: __d(__p) must not throw. 252 _Sp_counted_base_impl(_Ptr __p, _Deleter __d) 253 : _M_ptr(__p), _M_del(__d) { } 254 255 virtual void 256 _M_dispose() // nothrow 257 { _M_del(_M_ptr); } 258 259 virtual void* 260 _M_get_deleter(const std::type_info& __ti) 261 { 262#ifdef __GXX_RTTI 263 return __ti == typeid(_Deleter) ? &_M_del : 0; 264#else 265 return 0; 266#endif 267 } 268 269 private: 270 _Sp_counted_base_impl(const _Sp_counted_base_impl&); 271 _Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&); 272 273 _Ptr _M_ptr; // copy constructor must not throw 274 _Deleter _M_del; // copy constructor must not throw 275 }; 276 277 template<_Lock_policy _Lp = __default_lock_policy> 278 class __weak_count; 279 280 template<typename _Tp> 281 struct _Sp_deleter 282 { 283 typedef void result_type; 284 typedef _Tp* argument_type; 285 void operator()(_Tp* __p) const { delete __p; } 286 }; 287 288 template<_Lock_policy _Lp = __default_lock_policy> 289 class __shared_count 290 { 291 public: 292 __shared_count() 293 : _M_pi(0) // nothrow 294 { } 295 296 template<typename _Ptr> 297 __shared_count(_Ptr __p) : _M_pi(0) 298 { 299 __try 300 { 301 typedef typename std::tr1::remove_pointer<_Ptr>::type _Tp; 302 _M_pi = new _Sp_counted_base_impl<_Ptr, _Sp_deleter<_Tp>, _Lp>( 303 __p, _Sp_deleter<_Tp>()); 304 } 305 __catch(...) 306 { 307 delete __p; 308 __throw_exception_again; 309 } 310 } 311 312 template<typename _Ptr, typename _Deleter> 313 __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0) 314 { 315 __try 316 { 317 _M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d); 318 } 319 __catch(...) 320 { 321 __d(__p); // Call _Deleter on __p. 322 __throw_exception_again; 323 } 324 } 325 326 // Special case for auto_ptr<_Tp> to provide the strong guarantee. 327 template<typename _Tp> 328 explicit 329 __shared_count(std::auto_ptr<_Tp>& __r) 330 : _M_pi(new _Sp_counted_base_impl<_Tp*, 331 _Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>())) 332 { __r.release(); } 333 334 // Throw bad_weak_ptr when __r._M_get_use_count() == 0. 335 explicit 336 __shared_count(const __weak_count<_Lp>& __r); 337 338 ~__shared_count() // nothrow 339 { 340 if (_M_pi != 0) 341 _M_pi->_M_release(); 342 } 343 344 __shared_count(const __shared_count& __r) 345 : _M_pi(__r._M_pi) // nothrow 346 { 347 if (_M_pi != 0) 348 _M_pi->_M_add_ref_copy(); 349 } 350 351 __shared_count& 352 operator=(const __shared_count& __r) // nothrow 353 { 354 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 355 if (__tmp != _M_pi) 356 { 357 if (__tmp != 0) 358 __tmp->_M_add_ref_copy(); 359 if (_M_pi != 0) 360 _M_pi->_M_release(); 361 _M_pi = __tmp; 362 } 363 return *this; 364 } 365 366 void 367 _M_swap(__shared_count& __r) // nothrow 368 { 369 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 370 __r._M_pi = _M_pi; 371 _M_pi = __tmp; 372 } 373 374 long 375 _M_get_use_count() const // nothrow 376 { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } 377 378 bool 379 _M_unique() const // nothrow 380 { return this->_M_get_use_count() == 1; } 381 382 friend inline bool 383 operator==(const __shared_count& __a, const __shared_count& __b) 384 { return __a._M_pi == __b._M_pi; } 385 386 friend inline bool 387 operator<(const __shared_count& __a, const __shared_count& __b) 388 { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } 389 390 void* 391 _M_get_deleter(const std::type_info& __ti) const 392 { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; } 393 394 private: 395 friend class __weak_count<_Lp>; 396 397 _Sp_counted_base<_Lp>* _M_pi; 398 }; 399 400 401 template<_Lock_policy _Lp> 402 class __weak_count 403 { 404 public: 405 __weak_count() 406 : _M_pi(0) // nothrow 407 { } 408 409 __weak_count(const __shared_count<_Lp>& __r) 410 : _M_pi(__r._M_pi) // nothrow 411 { 412 if (_M_pi != 0) 413 _M_pi->_M_weak_add_ref(); 414 } 415 416 __weak_count(const __weak_count<_Lp>& __r) 417 : _M_pi(__r._M_pi) // nothrow 418 { 419 if (_M_pi != 0) 420 _M_pi->_M_weak_add_ref(); 421 } 422 423 ~__weak_count() // nothrow 424 { 425 if (_M_pi != 0) 426 _M_pi->_M_weak_release(); 427 } 428 429 __weak_count<_Lp>& 430 operator=(const __shared_count<_Lp>& __r) // nothrow 431 { 432 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 433 if (__tmp != 0) 434 __tmp->_M_weak_add_ref(); 435 if (_M_pi != 0) 436 _M_pi->_M_weak_release(); 437 _M_pi = __tmp; 438 return *this; 439 } 440 441 __weak_count<_Lp>& 442 operator=(const __weak_count<_Lp>& __r) // nothrow 443 { 444 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 445 if (__tmp != 0) 446 __tmp->_M_weak_add_ref(); 447 if (_M_pi != 0) 448 _M_pi->_M_weak_release(); 449 _M_pi = __tmp; 450 return *this; 451 } 452 453 void 454 _M_swap(__weak_count<_Lp>& __r) // nothrow 455 { 456 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 457 __r._M_pi = _M_pi; 458 _M_pi = __tmp; 459 } 460 461 long 462 _M_get_use_count() const // nothrow 463 { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } 464 465 friend inline bool 466 operator==(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b) 467 { return __a._M_pi == __b._M_pi; } 468 469 friend inline bool 470 operator<(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b) 471 { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } 472 473 private: 474 friend class __shared_count<_Lp>; 475 476 _Sp_counted_base<_Lp>* _M_pi; 477 }; 478 479 // now that __weak_count is defined we can define this constructor: 480 template<_Lock_policy _Lp> 481 inline 482 __shared_count<_Lp>:: 483 __shared_count(const __weak_count<_Lp>& __r) 484 : _M_pi(__r._M_pi) 485 { 486 if (_M_pi != 0) 487 _M_pi->_M_add_ref_lock(); 488 else 489 __throw_bad_weak_ptr(); 490 } 491 492 // Forward declarations. 493 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 494 class __shared_ptr; 495 496 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 497 class __weak_ptr; 498 499 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 500 class __enable_shared_from_this; 501 502 template<typename _Tp> 503 class shared_ptr; 504 505 template<typename _Tp> 506 class weak_ptr; 507 508 template<typename _Tp> 509 class enable_shared_from_this; 510 511 // Support for enable_shared_from_this. 512 513 // Friend of __enable_shared_from_this. 514 template<_Lock_policy _Lp, typename _Tp1, typename _Tp2> 515 void 516 __enable_shared_from_this_helper(const __shared_count<_Lp>&, 517 const __enable_shared_from_this<_Tp1, 518 _Lp>*, const _Tp2*); 519 520 // Friend of enable_shared_from_this. 521 template<typename _Tp1, typename _Tp2> 522 void 523 __enable_shared_from_this_helper(const __shared_count<>&, 524 const enable_shared_from_this<_Tp1>*, 525 const _Tp2*); 526 527 template<_Lock_policy _Lp> 528 inline void 529 __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) 530 { } 531 532 533 struct __static_cast_tag { }; 534 struct __const_cast_tag { }; 535 struct __dynamic_cast_tag { }; 536 537 // A smart pointer with reference-counted copy semantics. The 538 // object pointed to is deleted when the last shared_ptr pointing to 539 // it is destroyed or reset. 540 template<typename _Tp, _Lock_policy _Lp> 541 class __shared_ptr 542 { 543 public: 544 typedef _Tp element_type; 545 546 __shared_ptr() 547 : _M_ptr(0), _M_refcount() // never throws 548 { } 549 550 template<typename _Tp1> 551 explicit 552 __shared_ptr(_Tp1* __p) 553 : _M_ptr(__p), _M_refcount(__p) 554 { 555 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 556 typedef int _IsComplete[sizeof(_Tp1)]; 557 __enable_shared_from_this_helper(_M_refcount, __p, __p); 558 } 559 560 template<typename _Tp1, typename _Deleter> 561 __shared_ptr(_Tp1* __p, _Deleter __d) 562 : _M_ptr(__p), _M_refcount(__p, __d) 563 { 564 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 565 // TODO requires _Deleter CopyConstructible and __d(__p) well-formed 566 __enable_shared_from_this_helper(_M_refcount, __p, __p); 567 } 568 569 // generated copy constructor, assignment, destructor are fine. 570 571 template<typename _Tp1> 572 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) 573 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 574 { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } 575 576 template<typename _Tp1> 577 explicit 578 __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 579 : _M_refcount(__r._M_refcount) // may throw 580 { 581 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 582 // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount) 583 // did not throw. 584 _M_ptr = __r._M_ptr; 585 } 586 587#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 588 // Postcondition: use_count() == 1 and __r.get() == 0 589 template<typename _Tp1> 590 explicit 591 __shared_ptr(std::auto_ptr<_Tp1>& __r) 592 : _M_ptr(__r.get()), _M_refcount() 593 { // TODO requries delete __r.release() well-formed 594 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 595 typedef int _IsComplete[sizeof(_Tp1)]; 596 _Tp1* __tmp = __r.get(); 597 _M_refcount = __shared_count<_Lp>(__r); 598 __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp); 599 } 600 601#endif 602 603 template<typename _Tp1> 604 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __static_cast_tag) 605 : _M_ptr(static_cast<element_type*>(__r._M_ptr)), 606 _M_refcount(__r._M_refcount) 607 { } 608 609 template<typename _Tp1> 610 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __const_cast_tag) 611 : _M_ptr(const_cast<element_type*>(__r._M_ptr)), 612 _M_refcount(__r._M_refcount) 613 { } 614 615 template<typename _Tp1> 616 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __dynamic_cast_tag) 617 : _M_ptr(dynamic_cast<element_type*>(__r._M_ptr)), 618 _M_refcount(__r._M_refcount) 619 { 620 if (_M_ptr == 0) // need to allocate new counter -- the cast failed 621 _M_refcount = __shared_count<_Lp>(); 622 } 623 624 template<typename _Tp1> 625 __shared_ptr& 626 operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws 627 { 628 _M_ptr = __r._M_ptr; 629 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw 630 return *this; 631 } 632 633#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 634 template<typename _Tp1> 635 __shared_ptr& 636 operator=(std::auto_ptr<_Tp1>& __r) 637 { 638 __shared_ptr(__r).swap(*this); 639 return *this; 640 } 641#endif 642 643 void 644 reset() // never throws 645 { __shared_ptr().swap(*this); } 646 647 template<typename _Tp1> 648 void 649 reset(_Tp1* __p) // _Tp1 must be complete. 650 { 651 // Catch self-reset errors. 652 _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); 653 __shared_ptr(__p).swap(*this); 654 } 655 656 template<typename _Tp1, typename _Deleter> 657 void 658 reset(_Tp1* __p, _Deleter __d) 659 { __shared_ptr(__p, __d).swap(*this); } 660 661 // Allow class instantiation when _Tp is [cv-qual] void. 662 typename std::tr1::add_reference<_Tp>::type 663 operator*() const // never throws 664 { 665 _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); 666 return *_M_ptr; 667 } 668 669 _Tp* 670 operator->() const // never throws 671 { 672 _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); 673 return _M_ptr; 674 } 675 676 _Tp* 677 get() const // never throws 678 { return _M_ptr; } 679 680 // Implicit conversion to "bool" 681 private: 682 typedef _Tp* __shared_ptr::*__unspecified_bool_type; 683 684 public: 685 operator __unspecified_bool_type() const // never throws 686 { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; } 687 688 bool 689 unique() const // never throws 690 { return _M_refcount._M_unique(); } 691 692 long 693 use_count() const // never throws 694 { return _M_refcount._M_get_use_count(); } 695 696 void 697 swap(__shared_ptr<_Tp, _Lp>& __other) // never throws 698 { 699 std::swap(_M_ptr, __other._M_ptr); 700 _M_refcount._M_swap(__other._M_refcount); 701 } 702 703 private: 704 void* 705 _M_get_deleter(const std::type_info& __ti) const 706 { return _M_refcount._M_get_deleter(__ti); } 707 708 template<typename _Tp1, _Lock_policy _Lp1> 709 bool 710 _M_less(const __shared_ptr<_Tp1, _Lp1>& __rhs) const 711 { return _M_refcount < __rhs._M_refcount; } 712 713 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; 714 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; 715 716 template<typename _Del, typename _Tp1, _Lock_policy _Lp1> 717 friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&); 718 719 // Friends injected into enclosing namespace and found by ADL: 720 template<typename _Tp1> 721 friend inline bool 722 operator==(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) 723 { return __a.get() == __b.get(); } 724 725 template<typename _Tp1> 726 friend inline bool 727 operator!=(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) 728 { return __a.get() != __b.get(); } 729 730 template<typename _Tp1> 731 friend inline bool 732 operator<(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) 733 { return __a._M_less(__b); } 734 735 _Tp* _M_ptr; // Contained pointer. 736 __shared_count<_Lp> _M_refcount; // Reference counter. 737 }; 738 739 // 2.2.3.8 shared_ptr specialized algorithms. 740 template<typename _Tp, _Lock_policy _Lp> 741 inline void 742 swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) 743 { __a.swap(__b); } 744 745 // 2.2.3.9 shared_ptr casts 746 /* The seemingly equivalent 747 * shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get())) 748 * will eventually result in undefined behaviour, 749 * attempting to delete the same object twice. 750 */ 751 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 752 inline __shared_ptr<_Tp, _Lp> 753 static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 754 { return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag()); } 755 756 /* The seemingly equivalent 757 * shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get())) 758 * will eventually result in undefined behaviour, 759 * attempting to delete the same object twice. 760 */ 761 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 762 inline __shared_ptr<_Tp, _Lp> 763 const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 764 { return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag()); } 765 766 /* The seemingly equivalent 767 * shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get())) 768 * will eventually result in undefined behaviour, 769 * attempting to delete the same object twice. 770 */ 771 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 772 inline __shared_ptr<_Tp, _Lp> 773 dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 774 { return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag()); } 775 776 // 2.2.3.7 shared_ptr I/O 777 template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp> 778 std::basic_ostream<_Ch, _Tr>& 779 operator<<(std::basic_ostream<_Ch, _Tr>& __os, 780 const __shared_ptr<_Tp, _Lp>& __p) 781 { 782 __os << __p.get(); 783 return __os; 784 } 785 786 // 2.2.3.10 shared_ptr get_deleter (experimental) 787 template<typename _Del, typename _Tp, _Lock_policy _Lp> 788 inline _Del* 789 get_deleter(const __shared_ptr<_Tp, _Lp>& __p) 790 { 791#ifdef __GXX_RTTI 792 return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); 793#else 794 return 0; 795#endif 796 } 797 798 799 template<typename _Tp, _Lock_policy _Lp> 800 class __weak_ptr 801 { 802 public: 803 typedef _Tp element_type; 804 805 __weak_ptr() 806 : _M_ptr(0), _M_refcount() // never throws 807 { } 808 809 // Generated copy constructor, assignment, destructor are fine. 810 811 // The "obvious" converting constructor implementation: 812 // 813 // template<typename _Tp1> 814 // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 815 // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 816 // { } 817 // 818 // has a serious problem. 819 // 820 // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr) 821 // conversion may require access to *__r._M_ptr (virtual inheritance). 822 // 823 // It is not possible to avoid spurious access violations since 824 // in multithreaded programs __r._M_ptr may be invalidated at any point. 825 template<typename _Tp1> 826 __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 827 : _M_refcount(__r._M_refcount) // never throws 828 { 829 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 830 _M_ptr = __r.lock().get(); 831 } 832 833 template<typename _Tp1> 834 __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) 835 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 836 { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } 837 838 template<typename _Tp1> 839 __weak_ptr& 840 operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws 841 { 842 _M_ptr = __r.lock().get(); 843 _M_refcount = __r._M_refcount; 844 return *this; 845 } 846 847 template<typename _Tp1> 848 __weak_ptr& 849 operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws 850 { 851 _M_ptr = __r._M_ptr; 852 _M_refcount = __r._M_refcount; 853 return *this; 854 } 855 856 __shared_ptr<_Tp, _Lp> 857 lock() const // never throws 858 { 859#ifdef __GTHREADS 860 // Optimization: avoid throw overhead. 861 if (expired()) 862 return __shared_ptr<element_type, _Lp>(); 863 864 __try 865 { 866 return __shared_ptr<element_type, _Lp>(*this); 867 } 868 __catch(const bad_weak_ptr&) 869 { 870 // Q: How can we get here? 871 // A: Another thread may have invalidated r after the 872 // use_count test above. 873 return __shared_ptr<element_type, _Lp>(); 874 } 875 876#else 877 // Optimization: avoid try/catch overhead when single threaded. 878 return expired() ? __shared_ptr<element_type, _Lp>() 879 : __shared_ptr<element_type, _Lp>(*this); 880 881#endif 882 } // XXX MT 883 884 long 885 use_count() const // never throws 886 { return _M_refcount._M_get_use_count(); } 887 888 bool 889 expired() const // never throws 890 { return _M_refcount._M_get_use_count() == 0; } 891 892 void 893 reset() // never throws 894 { __weak_ptr().swap(*this); } 895 896 void 897 swap(__weak_ptr& __s) // never throws 898 { 899 std::swap(_M_ptr, __s._M_ptr); 900 _M_refcount._M_swap(__s._M_refcount); 901 } 902 903 private: 904 // Used by __enable_shared_from_this. 905 void 906 _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) 907 { 908 _M_ptr = __ptr; 909 _M_refcount = __refcount; 910 } 911 912 template<typename _Tp1> 913 bool 914 _M_less(const __weak_ptr<_Tp1, _Lp>& __rhs) const 915 { return _M_refcount < __rhs._M_refcount; } 916 917 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; 918 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; 919 friend class __enable_shared_from_this<_Tp, _Lp>; 920 friend class enable_shared_from_this<_Tp>; 921 922 // Friend injected into namespace and found by ADL. 923 template<typename _Tp1> 924 friend inline bool 925 operator<(const __weak_ptr& __lhs, const __weak_ptr<_Tp1, _Lp>& __rhs) 926 { return __lhs._M_less(__rhs); } 927 928 _Tp* _M_ptr; // Contained pointer. 929 __weak_count<_Lp> _M_refcount; // Reference counter. 930 }; 931 932 // 2.2.4.7 weak_ptr specialized algorithms. 933 template<typename _Tp, _Lock_policy _Lp> 934 inline void 935 swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) 936 { __a.swap(__b); } 937 938 939 template<typename _Tp, _Lock_policy _Lp> 940 class __enable_shared_from_this 941 { 942 protected: 943 __enable_shared_from_this() { } 944 945 __enable_shared_from_this(const __enable_shared_from_this&) { } 946 947 __enable_shared_from_this& 948 operator=(const __enable_shared_from_this&) 949 { return *this; } 950 951 ~__enable_shared_from_this() { } 952 953 public: 954 __shared_ptr<_Tp, _Lp> 955 shared_from_this() 956 { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } 957 958 __shared_ptr<const _Tp, _Lp> 959 shared_from_this() const 960 { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); } 961 962 private: 963 template<typename _Tp1> 964 void 965 _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const 966 { _M_weak_this._M_assign(__p, __n); } 967 968 template<typename _Tp1> 969 friend void 970 __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn, 971 const __enable_shared_from_this* __pe, 972 const _Tp1* __px) 973 { 974 if (__pe != 0) 975 __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); 976 } 977 978 mutable __weak_ptr<_Tp, _Lp> _M_weak_this; 979 }; 980 981 982 // The actual shared_ptr, with forwarding constructors and 983 // assignment operators. 984 template<typename _Tp> 985 class shared_ptr 986 : public __shared_ptr<_Tp> 987 { 988 public: 989 shared_ptr() 990 : __shared_ptr<_Tp>() { } 991 992 template<typename _Tp1> 993 explicit 994 shared_ptr(_Tp1* __p) 995 : __shared_ptr<_Tp>(__p) { } 996 997 template<typename _Tp1, typename _Deleter> 998 shared_ptr(_Tp1* __p, _Deleter __d) 999 : __shared_ptr<_Tp>(__p, __d) { } 1000 1001 template<typename _Tp1> 1002 shared_ptr(const shared_ptr<_Tp1>& __r) 1003 : __shared_ptr<_Tp>(__r) { } 1004 1005 template<typename _Tp1> 1006 explicit 1007 shared_ptr(const weak_ptr<_Tp1>& __r) 1008 : __shared_ptr<_Tp>(__r) { } 1009 1010#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 1011 template<typename _Tp1> 1012 explicit 1013 shared_ptr(std::auto_ptr<_Tp1>& __r) 1014 : __shared_ptr<_Tp>(__r) { } 1015#endif 1016 1017 template<typename _Tp1> 1018 shared_ptr(const shared_ptr<_Tp1>& __r, __static_cast_tag) 1019 : __shared_ptr<_Tp>(__r, __static_cast_tag()) { } 1020 1021 template<typename _Tp1> 1022 shared_ptr(const shared_ptr<_Tp1>& __r, __const_cast_tag) 1023 : __shared_ptr<_Tp>(__r, __const_cast_tag()) { } 1024 1025 template<typename _Tp1> 1026 shared_ptr(const shared_ptr<_Tp1>& __r, __dynamic_cast_tag) 1027 : __shared_ptr<_Tp>(__r, __dynamic_cast_tag()) { } 1028 1029 template<typename _Tp1> 1030 shared_ptr& 1031 operator=(const shared_ptr<_Tp1>& __r) // never throws 1032 { 1033 this->__shared_ptr<_Tp>::operator=(__r); 1034 return *this; 1035 } 1036 1037#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 1038 template<typename _Tp1> 1039 shared_ptr& 1040 operator=(std::auto_ptr<_Tp1>& __r) 1041 { 1042 this->__shared_ptr<_Tp>::operator=(__r); 1043 return *this; 1044 } 1045#endif 1046 }; 1047 1048 // 2.2.3.8 shared_ptr specialized algorithms. 1049 template<typename _Tp> 1050 inline void 1051 swap(__shared_ptr<_Tp>& __a, __shared_ptr<_Tp>& __b) 1052 { __a.swap(__b); } 1053 1054 template<typename _Tp, typename _Tp1> 1055 inline shared_ptr<_Tp> 1056 static_pointer_cast(const shared_ptr<_Tp1>& __r) 1057 { return shared_ptr<_Tp>(__r, __static_cast_tag()); } 1058 1059 template<typename _Tp, typename _Tp1> 1060 inline shared_ptr<_Tp> 1061 const_pointer_cast(const shared_ptr<_Tp1>& __r) 1062 { return shared_ptr<_Tp>(__r, __const_cast_tag()); } 1063 1064 template<typename _Tp, typename _Tp1> 1065 inline shared_ptr<_Tp> 1066 dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) 1067 { return shared_ptr<_Tp>(__r, __dynamic_cast_tag()); } 1068 1069 1070 // The actual weak_ptr, with forwarding constructors and 1071 // assignment operators. 1072 template<typename _Tp> 1073 class weak_ptr 1074 : public __weak_ptr<_Tp> 1075 { 1076 public: 1077 weak_ptr() 1078 : __weak_ptr<_Tp>() { } 1079 1080 template<typename _Tp1> 1081 weak_ptr(const weak_ptr<_Tp1>& __r) 1082 : __weak_ptr<_Tp>(__r) { } 1083 1084 template<typename _Tp1> 1085 weak_ptr(const shared_ptr<_Tp1>& __r) 1086 : __weak_ptr<_Tp>(__r) { } 1087 1088 template<typename _Tp1> 1089 weak_ptr& 1090 operator=(const weak_ptr<_Tp1>& __r) // never throws 1091 { 1092 this->__weak_ptr<_Tp>::operator=(__r); 1093 return *this; 1094 } 1095 1096 template<typename _Tp1> 1097 weak_ptr& 1098 operator=(const shared_ptr<_Tp1>& __r) // never throws 1099 { 1100 this->__weak_ptr<_Tp>::operator=(__r); 1101 return *this; 1102 } 1103 1104 shared_ptr<_Tp> 1105 lock() const // never throws 1106 { 1107#ifdef __GTHREADS 1108 if (this->expired()) 1109 return shared_ptr<_Tp>(); 1110 1111 __try 1112 { 1113 return shared_ptr<_Tp>(*this); 1114 } 1115 __catch(const bad_weak_ptr&) 1116 { 1117 return shared_ptr<_Tp>(); 1118 } 1119#else 1120 return this->expired() ? shared_ptr<_Tp>() 1121 : shared_ptr<_Tp>(*this); 1122#endif 1123 } 1124 }; 1125 1126 template<typename _Tp> 1127 class enable_shared_from_this 1128 { 1129 protected: 1130 enable_shared_from_this() { } 1131 1132 enable_shared_from_this(const enable_shared_from_this&) { } 1133 1134 enable_shared_from_this& 1135 operator=(const enable_shared_from_this&) 1136 { return *this; } 1137 1138 ~enable_shared_from_this() { } 1139 1140 public: 1141 shared_ptr<_Tp> 1142 shared_from_this() 1143 { return shared_ptr<_Tp>(this->_M_weak_this); } 1144 1145 shared_ptr<const _Tp> 1146 shared_from_this() const 1147 { return shared_ptr<const _Tp>(this->_M_weak_this); } 1148 1149 private: 1150 template<typename _Tp1> 1151 void 1152 _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const 1153 { _M_weak_this._M_assign(__p, __n); } 1154 1155 template<typename _Tp1> 1156 friend void 1157 __enable_shared_from_this_helper(const __shared_count<>& __pn, 1158 const enable_shared_from_this* __pe, 1159 const _Tp1* __px) 1160 { 1161 if (__pe != 0) 1162 __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); 1163 } 1164 1165 mutable weak_ptr<_Tp> _M_weak_this; 1166 }; 1167 1168_GLIBCXX_END_NAMESPACE_VERSION 1169} 1170} 1171 1172#endif // _TR1_SHARED_PTR_H 1173