1 // <tr1/shared_ptr.h> -*- C++ -*- 2 3 // Copyright (C) 2007, 2008, 2009 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 * You should not attempt to use it directly. 47 */ 48 49 #ifndef _TR1_SHARED_PTR_H 50 #define _TR1_SHARED_PTR_H 1 51 52 #if defined(_GLIBCXX_INCLUDE_AS_CXX0X) 53 # error TR1 header cannot be included from C++0x header 54 #endif 55 56 namespace std 57 { 58 namespace tr1 59 { 60 61 template<typename _Ptr, typename _Deleter, _Lock_policy _Lp> 62 class _Sp_counted_base_impl 63 : public _Sp_counted_base<_Lp> 64 { 65 public: 66 /** 67 * @brief 68 * @pre __d(__p) must not throw. 69 */ 70 _Sp_counted_base_impl(_Ptr __p, _Deleter __d) 71 : _M_ptr(__p), _M_del(__d) { } 72 73 virtual void 74 _M_dispose() // nothrow 75 { _M_del(_M_ptr); } 76 77 virtual void* 78 _M_get_deleter(const std::type_info& __ti) 79 { return __ti == typeid(_Deleter) ? &_M_del : 0; } 80 81 private: 82 _Sp_counted_base_impl(const _Sp_counted_base_impl&); 83 _Sp_counted_base_impl& operator=(const _Sp_counted_base_impl&); 84 85 _Ptr _M_ptr; // copy constructor must not throw 86 _Deleter _M_del; // copy constructor must not throw 87 }; 88 89 template<_Lock_policy _Lp = __default_lock_policy> 90 class __weak_count; 91 92 template<typename _Tp> 93 struct _Sp_deleter 94 { 95 typedef void result_type; 96 typedef _Tp* argument_type; 97 void operator()(_Tp* __p) const { delete __p; } 98 }; 99 100 template<_Lock_policy _Lp = __default_lock_policy> 101 class __shared_count 102 { 103 public: 104 __shared_count() 105 : _M_pi(0) // nothrow 106 { } 107 108 template<typename _Ptr> 109 __shared_count(_Ptr __p) : _M_pi(0) 110 { 111 __try 112 { 113 typedef typename std::tr1::remove_pointer<_Ptr>::type _Tp; 114 _M_pi = new _Sp_counted_base_impl<_Ptr, _Sp_deleter<_Tp>, _Lp>( 115 __p, _Sp_deleter<_Tp>()); 116 } 117 __catch(...) 118 { 119 delete __p; 120 __throw_exception_again; 121 } 122 } 123 124 template<typename _Ptr, typename _Deleter> 125 __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0) 126 { 127 __try 128 { 129 _M_pi = new _Sp_counted_base_impl<_Ptr, _Deleter, _Lp>(__p, __d); 130 } 131 __catch(...) 132 { 133 __d(__p); // Call _Deleter on __p. 134 __throw_exception_again; 135 } 136 } 137 138 // Special case for auto_ptr<_Tp> to provide the strong guarantee. 139 template<typename _Tp> 140 explicit 141 __shared_count(std::auto_ptr<_Tp>& __r) 142 : _M_pi(new _Sp_counted_base_impl<_Tp*, 143 _Sp_deleter<_Tp>, _Lp >(__r.get(), _Sp_deleter<_Tp>())) 144 { __r.release(); } 145 146 // Throw bad_weak_ptr when __r._M_get_use_count() == 0. 147 explicit 148 __shared_count(const __weak_count<_Lp>& __r); 149 150 ~__shared_count() // nothrow 151 { 152 if (_M_pi != 0) 153 _M_pi->_M_release(); 154 } 155 156 __shared_count(const __shared_count& __r) 157 : _M_pi(__r._M_pi) // nothrow 158 { 159 if (_M_pi != 0) 160 _M_pi->_M_add_ref_copy(); 161 } 162 163 __shared_count& 164 operator=(const __shared_count& __r) // nothrow 165 { 166 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 167 if (__tmp != _M_pi) 168 { 169 if (__tmp != 0) 170 __tmp->_M_add_ref_copy(); 171 if (_M_pi != 0) 172 _M_pi->_M_release(); 173 _M_pi = __tmp; 174 } 175 return *this; 176 } 177 178 void 179 _M_swap(__shared_count& __r) // nothrow 180 { 181 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 182 __r._M_pi = _M_pi; 183 _M_pi = __tmp; 184 } 185 186 long 187 _M_get_use_count() const // nothrow 188 { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } 189 190 bool 191 _M_unique() const // nothrow 192 { return this->_M_get_use_count() == 1; } 193 194 friend inline bool 195 operator==(const __shared_count& __a, const __shared_count& __b) 196 { return __a._M_pi == __b._M_pi; } 197 198 friend inline bool 199 operator<(const __shared_count& __a, const __shared_count& __b) 200 { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } 201 202 void* 203 _M_get_deleter(const std::type_info& __ti) const 204 { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; } 205 206 private: 207 friend class __weak_count<_Lp>; 208 209 _Sp_counted_base<_Lp>* _M_pi; 210 }; 211 212 213 template<_Lock_policy _Lp> 214 class __weak_count 215 { 216 public: 217 __weak_count() 218 : _M_pi(0) // nothrow 219 { } 220 221 __weak_count(const __shared_count<_Lp>& __r) 222 : _M_pi(__r._M_pi) // nothrow 223 { 224 if (_M_pi != 0) 225 _M_pi->_M_weak_add_ref(); 226 } 227 228 __weak_count(const __weak_count<_Lp>& __r) 229 : _M_pi(__r._M_pi) // nothrow 230 { 231 if (_M_pi != 0) 232 _M_pi->_M_weak_add_ref(); 233 } 234 235 ~__weak_count() // nothrow 236 { 237 if (_M_pi != 0) 238 _M_pi->_M_weak_release(); 239 } 240 241 __weak_count<_Lp>& 242 operator=(const __shared_count<_Lp>& __r) // nothrow 243 { 244 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 245 if (__tmp != 0) 246 __tmp->_M_weak_add_ref(); 247 if (_M_pi != 0) 248 _M_pi->_M_weak_release(); 249 _M_pi = __tmp; 250 return *this; 251 } 252 253 __weak_count<_Lp>& 254 operator=(const __weak_count<_Lp>& __r) // nothrow 255 { 256 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 257 if (__tmp != 0) 258 __tmp->_M_weak_add_ref(); 259 if (_M_pi != 0) 260 _M_pi->_M_weak_release(); 261 _M_pi = __tmp; 262 return *this; 263 } 264 265 void 266 _M_swap(__weak_count<_Lp>& __r) // nothrow 267 { 268 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 269 __r._M_pi = _M_pi; 270 _M_pi = __tmp; 271 } 272 273 long 274 _M_get_use_count() const // nothrow 275 { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } 276 277 friend inline bool 278 operator==(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b) 279 { return __a._M_pi == __b._M_pi; } 280 281 friend inline bool 282 operator<(const __weak_count<_Lp>& __a, const __weak_count<_Lp>& __b) 283 { return std::less<_Sp_counted_base<_Lp>*>()(__a._M_pi, __b._M_pi); } 284 285 private: 286 friend class __shared_count<_Lp>; 287 288 _Sp_counted_base<_Lp>* _M_pi; 289 }; 290 291 // now that __weak_count is defined we can define this constructor: 292 template<_Lock_policy _Lp> 293 inline 294 __shared_count<_Lp>:: 295 __shared_count(const __weak_count<_Lp>& __r) 296 : _M_pi(__r._M_pi) 297 { 298 if (_M_pi != 0) 299 _M_pi->_M_add_ref_lock(); 300 else 301 __throw_bad_weak_ptr(); 302 } 303 304 // Forward declarations. 305 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 306 class __shared_ptr; 307 308 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 309 class __weak_ptr; 310 311 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 312 class __enable_shared_from_this; 313 314 template<typename _Tp> 315 class shared_ptr; 316 317 template<typename _Tp> 318 class weak_ptr; 319 320 template<typename _Tp> 321 class enable_shared_from_this; 322 323 // Support for enable_shared_from_this. 324 325 // Friend of __enable_shared_from_this. 326 template<_Lock_policy _Lp, typename _Tp1, typename _Tp2> 327 void 328 __enable_shared_from_this_helper(const __shared_count<_Lp>&, 329 const __enable_shared_from_this<_Tp1, 330 _Lp>*, const _Tp2*); 331 332 // Friend of enable_shared_from_this. 333 template<typename _Tp1, typename _Tp2> 334 void 335 __enable_shared_from_this_helper(const __shared_count<>&, 336 const enable_shared_from_this<_Tp1>*, 337 const _Tp2*); 338 339 template<_Lock_policy _Lp> 340 inline void 341 __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) 342 { } 343 344 345 struct __static_cast_tag { }; 346 struct __const_cast_tag { }; 347 struct __dynamic_cast_tag { }; 348 349 /** 350 * @class __shared_ptr 351 * 352 * A smart pointer with reference-counted copy semantics. 353 * The object pointed to is deleted when the last shared_ptr pointing to 354 * it is destroyed or reset. 355 */ 356 template<typename _Tp, _Lock_policy _Lp> 357 class __shared_ptr 358 { 359 public: 360 typedef _Tp element_type; 361 362 /** @brief Construct an empty %__shared_ptr. 363 * @post use_count()==0 && get()==0 364 */ 365 __shared_ptr() 366 : _M_ptr(0), _M_refcount() // never throws 367 { } 368 369 /** @brief Construct a %__shared_ptr that owns the pointer @a __p. 370 * @param __p A pointer that is convertible to element_type*. 371 * @post use_count() == 1 && get() == __p 372 * @throw std::bad_alloc, in which case @c delete @a __p is called. 373 */ 374 template<typename _Tp1> 375 explicit 376 __shared_ptr(_Tp1* __p) 377 : _M_ptr(__p), _M_refcount(__p) 378 { 379 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 380 // __glibcxx_function_requires(_CompleteConcept<_Tp1*>) 381 __enable_shared_from_this_helper(_M_refcount, __p, __p); 382 } 383 384 // 385 // Requirements: _Deleter's copy constructor and destructor must 386 // not throw 387 // 388 // __shared_ptr will release __p by calling __d(__p) 389 // 390 /** @brief Construct a %__shared_ptr that owns the pointer @a __p 391 * and the deleter @a __d. 392 * @param __p A pointer. 393 * @param __d A deleter. 394 * @post use_count() == 1 && get() == __p 395 * @throw std::bad_alloc, in which case @a __d(__p) is called. 396 */ 397 template<typename _Tp1, typename _Deleter> 398 __shared_ptr(_Tp1* __p, _Deleter __d) 399 : _M_ptr(__p), _M_refcount(__p, __d) 400 { 401 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 402 // TODO requires _Deleter CopyConstructible and __d(__p) well-formed 403 __enable_shared_from_this_helper(_M_refcount, __p, __p); 404 } 405 406 // generated copy constructor, assignment, destructor are fine. 407 408 /** @brief If @a __r is empty, constructs an empty %__shared_ptr; 409 * otherwise construct a %__shared_ptr that shares ownership 410 * with @a __r. 411 * @param __r A %__shared_ptr. 412 * @post get() == __r.get() && use_count() == __r.use_count() 413 */ 414 template<typename _Tp1> 415 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) 416 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 417 { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } 418 419 /** @brief Constructs a %__shared_ptr that shares ownership with @a __r 420 * and stores a copy of the pointer stored in @a __r. 421 * @param __r A weak_ptr. 422 * @post use_count() == __r.use_count() 423 * @throw bad_weak_ptr when __r.expired(), 424 * in which case the constructor has no effect. 425 */ 426 template<typename _Tp1> 427 explicit 428 __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 429 : _M_refcount(__r._M_refcount) // may throw 430 { 431 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 432 // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount) 433 // did not throw. 434 _M_ptr = __r._M_ptr; 435 } 436 437 #if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED 438 /** 439 * @post use_count() == 1 and __r.get() == 0 440 */ 441 template<typename _Tp1> 442 explicit 443 __shared_ptr(std::auto_ptr<_Tp1>& __r) 444 : _M_ptr(__r.get()), _M_refcount() 445 { 446 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 447 // TODO requires _Tp1 is complete, delete __r.release() well-formed 448 _Tp1* __tmp = __r.get(); 449 _M_refcount = __shared_count<_Lp>(__r); 450 __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp); 451 } 452 453 #endif 454 455 template<typename _Tp1> 456 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __static_cast_tag) 457 : _M_ptr(static_cast<element_type*>(__r._M_ptr)), 458 _M_refcount(__r._M_refcount) 459 { } 460 461 template<typename _Tp1> 462 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __const_cast_tag) 463 : _M_ptr(const_cast<element_type*>(__r._M_ptr)), 464 _M_refcount(__r._M_refcount) 465 { } 466 467 template<typename _Tp1> 468 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, __dynamic_cast_tag) 469 : _M_ptr(dynamic_cast<element_type*>(__r._M_ptr)), 470 _M_refcount(__r._M_refcount) 471 { 472 if (_M_ptr == 0) // need to allocate new counter -- the cast failed 473 _M_refcount = __shared_count<_Lp>(); 474 } 475 476 template<typename _Tp1> 477 __shared_ptr& 478 operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws 479 { 480 _M_ptr = __r._M_ptr; 481 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw 482 return *this; 483 } 484 485 #if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED 486 template<typename _Tp1> 487 __shared_ptr& 488 operator=(std::auto_ptr<_Tp1>& __r) 489 { 490 __shared_ptr(__r).swap(*this); 491 return *this; 492 } 493 #endif 494 495 void 496 reset() // never throws 497 { __shared_ptr().swap(*this); } 498 499 template<typename _Tp1> 500 void 501 reset(_Tp1* __p) // _Tp1 must be complete. 502 { 503 // Catch self-reset errors. 504 _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); 505 __shared_ptr(__p).swap(*this); 506 } 507 508 template<typename _Tp1, typename _Deleter> 509 void 510 reset(_Tp1* __p, _Deleter __d) 511 { __shared_ptr(__p, __d).swap(*this); } 512 513 // Allow class instantiation when _Tp is [cv-qual] void. 514 typename std::tr1::add_reference<_Tp>::type 515 operator*() const // never throws 516 { 517 _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); 518 return *_M_ptr; 519 } 520 521 _Tp* 522 operator->() const // never throws 523 { 524 _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); 525 return _M_ptr; 526 } 527 528 _Tp* 529 get() const // never throws 530 { return _M_ptr; } 531 532 // Implicit conversion to "bool" 533 private: 534 typedef _Tp* __shared_ptr::*__unspecified_bool_type; 535 536 public: 537 operator __unspecified_bool_type() const // never throws 538 { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; } 539 540 bool 541 unique() const // never throws 542 { return _M_refcount._M_unique(); } 543 544 long 545 use_count() const // never throws 546 { return _M_refcount._M_get_use_count(); } 547 548 void 549 swap(__shared_ptr<_Tp, _Lp>& __other) // never throws 550 { 551 std::swap(_M_ptr, __other._M_ptr); 552 _M_refcount._M_swap(__other._M_refcount); 553 } 554 555 private: 556 void* 557 _M_get_deleter(const std::type_info& __ti) const 558 { return _M_refcount._M_get_deleter(__ti); } 559 560 template<typename _Tp1, _Lock_policy _Lp1> 561 bool 562 _M_less(const __shared_ptr<_Tp1, _Lp1>& __rhs) const 563 { return _M_refcount < __rhs._M_refcount; } 564 565 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; 566 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; 567 568 template<typename _Del, typename _Tp1, _Lock_policy _Lp1> 569 friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&); 570 571 // Friends injected into enclosing namespace and found by ADL: 572 template<typename _Tp1> 573 friend inline bool 574 operator==(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) 575 { return __a.get() == __b.get(); } 576 577 template<typename _Tp1> 578 friend inline bool 579 operator!=(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) 580 { return __a.get() != __b.get(); } 581 582 template<typename _Tp1> 583 friend inline bool 584 operator<(const __shared_ptr& __a, const __shared_ptr<_Tp1, _Lp>& __b) 585 { return __a._M_less(__b); } 586 587 _Tp* _M_ptr; // Contained pointer. 588 __shared_count<_Lp> _M_refcount; // Reference counter. 589 }; 590 591 // 2.2.3.8 shared_ptr specialized algorithms. 592 template<typename _Tp, _Lock_policy _Lp> 593 inline void 594 swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) 595 { __a.swap(__b); } 596 597 // 2.2.3.9 shared_ptr casts 598 /** @warning The seemingly equivalent 599 * <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code> 600 * will eventually result in undefined behaviour, 601 * attempting to delete the same object twice. 602 */ 603 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 604 inline __shared_ptr<_Tp, _Lp> 605 static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 606 { return __shared_ptr<_Tp, _Lp>(__r, __static_cast_tag()); } 607 608 /** @warning The seemingly equivalent 609 * <code>shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))</code> 610 * will eventually result in undefined behaviour, 611 * attempting to delete the same object twice. 612 */ 613 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 614 inline __shared_ptr<_Tp, _Lp> 615 const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 616 { return __shared_ptr<_Tp, _Lp>(__r, __const_cast_tag()); } 617 618 /** @warning The seemingly equivalent 619 * <code>shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))</code> 620 * will eventually result in undefined behaviour, 621 * attempting to delete the same object twice. 622 */ 623 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 624 inline __shared_ptr<_Tp, _Lp> 625 dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 626 { return __shared_ptr<_Tp, _Lp>(__r, __dynamic_cast_tag()); } 627 628 // 2.2.3.7 shared_ptr I/O 629 template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp> 630 std::basic_ostream<_Ch, _Tr>& 631 operator<<(std::basic_ostream<_Ch, _Tr>& __os, 632 const __shared_ptr<_Tp, _Lp>& __p) 633 { 634 __os << __p.get(); 635 return __os; 636 } 637 638 // 2.2.3.10 shared_ptr get_deleter (experimental) 639 template<typename _Del, typename _Tp, _Lock_policy _Lp> 640 inline _Del* 641 get_deleter(const __shared_ptr<_Tp, _Lp>& __p) 642 { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } 643 644 645 template<typename _Tp, _Lock_policy _Lp> 646 class __weak_ptr 647 { 648 public: 649 typedef _Tp element_type; 650 651 __weak_ptr() 652 : _M_ptr(0), _M_refcount() // never throws 653 { } 654 655 // Generated copy constructor, assignment, destructor are fine. 656 657 // The "obvious" converting constructor implementation: 658 // 659 // template<typename _Tp1> 660 // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 661 // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 662 // { } 663 // 664 // has a serious problem. 665 // 666 // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr) 667 // conversion may require access to *__r._M_ptr (virtual inheritance). 668 // 669 // It is not possible to avoid spurious access violations since 670 // in multithreaded programs __r._M_ptr may be invalidated at any point. 671 template<typename _Tp1> 672 __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 673 : _M_refcount(__r._M_refcount) // never throws 674 { 675 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 676 _M_ptr = __r.lock().get(); 677 } 678 679 template<typename _Tp1> 680 __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) 681 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 682 { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } 683 684 template<typename _Tp1> 685 __weak_ptr& 686 operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws 687 { 688 _M_ptr = __r.lock().get(); 689 _M_refcount = __r._M_refcount; 690 return *this; 691 } 692 693 template<typename _Tp1> 694 __weak_ptr& 695 operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws 696 { 697 _M_ptr = __r._M_ptr; 698 _M_refcount = __r._M_refcount; 699 return *this; 700 } 701 702 __shared_ptr<_Tp, _Lp> 703 lock() const // never throws 704 { 705 #ifdef __GTHREADS 706 // Optimization: avoid throw overhead. 707 if (expired()) 708 return __shared_ptr<element_type, _Lp>(); 709 710 __try 711 { 712 return __shared_ptr<element_type, _Lp>(*this); 713 } 714 __catch(const bad_weak_ptr&) 715 { 716 // Q: How can we get here? 717 // A: Another thread may have invalidated r after the 718 // use_count test above. 719 return __shared_ptr<element_type, _Lp>(); 720 } 721 722 #else 723 // Optimization: avoid try/catch overhead when single threaded. 724 return expired() ? __shared_ptr<element_type, _Lp>() 725 : __shared_ptr<element_type, _Lp>(*this); 726 727 #endif 728 } // XXX MT 729 730 long 731 use_count() const // never throws 732 { return _M_refcount._M_get_use_count(); } 733 734 bool 735 expired() const // never throws 736 { return _M_refcount._M_get_use_count() == 0; } 737 738 void 739 reset() // never throws 740 { __weak_ptr().swap(*this); } 741 742 void 743 swap(__weak_ptr& __s) // never throws 744 { 745 std::swap(_M_ptr, __s._M_ptr); 746 _M_refcount._M_swap(__s._M_refcount); 747 } 748 749 private: 750 // Used by __enable_shared_from_this. 751 void 752 _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) 753 { 754 _M_ptr = __ptr; 755 _M_refcount = __refcount; 756 } 757 758 template<typename _Tp1> 759 bool 760 _M_less(const __weak_ptr<_Tp1, _Lp>& __rhs) const 761 { return _M_refcount < __rhs._M_refcount; } 762 763 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; 764 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; 765 friend class __enable_shared_from_this<_Tp, _Lp>; 766 friend class enable_shared_from_this<_Tp>; 767 768 // Friend injected into namespace and found by ADL. 769 template<typename _Tp1> 770 friend inline bool 771 operator<(const __weak_ptr& __lhs, const __weak_ptr<_Tp1, _Lp>& __rhs) 772 { return __lhs._M_less(__rhs); } 773 774 _Tp* _M_ptr; // Contained pointer. 775 __weak_count<_Lp> _M_refcount; // Reference counter. 776 }; 777 778 // 2.2.4.7 weak_ptr specialized algorithms. 779 template<typename _Tp, _Lock_policy _Lp> 780 inline void 781 swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) 782 { __a.swap(__b); } 783 784 785 template<typename _Tp, _Lock_policy _Lp> 786 class __enable_shared_from_this 787 { 788 protected: 789 __enable_shared_from_this() { } 790 791 __enable_shared_from_this(const __enable_shared_from_this&) { } 792 793 __enable_shared_from_this& 794 operator=(const __enable_shared_from_this&) 795 { return *this; } 796 797 ~__enable_shared_from_this() { } 798 799 public: 800 __shared_ptr<_Tp, _Lp> 801 shared_from_this() 802 { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } 803 804 __shared_ptr<const _Tp, _Lp> 805 shared_from_this() const 806 { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); } 807 808 private: 809 template<typename _Tp1> 810 void 811 _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const 812 { _M_weak_this._M_assign(__p, __n); } 813 814 template<typename _Tp1> 815 friend void 816 __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn, 817 const __enable_shared_from_this* __pe, 818 const _Tp1* __px) 819 { 820 if (__pe != 0) 821 __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); 822 } 823 824 mutable __weak_ptr<_Tp, _Lp> _M_weak_this; 825 }; 826 827 828 /// shared_ptr 829 // The actual shared_ptr, with forwarding constructors and 830 // assignment operators. 831 template<typename _Tp> 832 class shared_ptr 833 : public __shared_ptr<_Tp> 834 { 835 public: 836 shared_ptr() 837 : __shared_ptr<_Tp>() { } 838 839 template<typename _Tp1> 840 explicit 841 shared_ptr(_Tp1* __p) 842 : __shared_ptr<_Tp>(__p) { } 843 844 template<typename _Tp1, typename _Deleter> 845 shared_ptr(_Tp1* __p, _Deleter __d) 846 : __shared_ptr<_Tp>(__p, __d) { } 847 848 template<typename _Tp1> 849 shared_ptr(const shared_ptr<_Tp1>& __r) 850 : __shared_ptr<_Tp>(__r) { } 851 852 template<typename _Tp1> 853 explicit 854 shared_ptr(const weak_ptr<_Tp1>& __r) 855 : __shared_ptr<_Tp>(__r) { } 856 857 #if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED 858 template<typename _Tp1> 859 explicit 860 shared_ptr(std::auto_ptr<_Tp1>& __r) 861 : __shared_ptr<_Tp>(__r) { } 862 #endif 863 864 template<typename _Tp1> 865 shared_ptr(const shared_ptr<_Tp1>& __r, __static_cast_tag) 866 : __shared_ptr<_Tp>(__r, __static_cast_tag()) { } 867 868 template<typename _Tp1> 869 shared_ptr(const shared_ptr<_Tp1>& __r, __const_cast_tag) 870 : __shared_ptr<_Tp>(__r, __const_cast_tag()) { } 871 872 template<typename _Tp1> 873 shared_ptr(const shared_ptr<_Tp1>& __r, __dynamic_cast_tag) 874 : __shared_ptr<_Tp>(__r, __dynamic_cast_tag()) { } 875 876 template<typename _Tp1> 877 shared_ptr& 878 operator=(const shared_ptr<_Tp1>& __r) // never throws 879 { 880 this->__shared_ptr<_Tp>::operator=(__r); 881 return *this; 882 } 883 884 #if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED 885 template<typename _Tp1> 886 shared_ptr& 887 operator=(std::auto_ptr<_Tp1>& __r) 888 { 889 this->__shared_ptr<_Tp>::operator=(__r); 890 return *this; 891 } 892 #endif 893 }; 894 895 // 2.2.3.8 shared_ptr specialized algorithms. 896 template<typename _Tp> 897 inline void 898 swap(__shared_ptr<_Tp>& __a, __shared_ptr<_Tp>& __b) 899 { __a.swap(__b); } 900 901 template<typename _Tp, typename _Tp1> 902 inline shared_ptr<_Tp> 903 static_pointer_cast(const shared_ptr<_Tp1>& __r) 904 { return shared_ptr<_Tp>(__r, __static_cast_tag()); } 905 906 template<typename _Tp, typename _Tp1> 907 inline shared_ptr<_Tp> 908 const_pointer_cast(const shared_ptr<_Tp1>& __r) 909 { return shared_ptr<_Tp>(__r, __const_cast_tag()); } 910 911 template<typename _Tp, typename _Tp1> 912 inline shared_ptr<_Tp> 913 dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) 914 { return shared_ptr<_Tp>(__r, __dynamic_cast_tag()); } 915 916 917 /// weak_ptr 918 // The actual weak_ptr, with forwarding constructors and 919 // assignment operators. 920 template<typename _Tp> 921 class weak_ptr 922 : public __weak_ptr<_Tp> 923 { 924 public: 925 weak_ptr() 926 : __weak_ptr<_Tp>() { } 927 928 template<typename _Tp1> 929 weak_ptr(const weak_ptr<_Tp1>& __r) 930 : __weak_ptr<_Tp>(__r) { } 931 932 template<typename _Tp1> 933 weak_ptr(const shared_ptr<_Tp1>& __r) 934 : __weak_ptr<_Tp>(__r) { } 935 936 template<typename _Tp1> 937 weak_ptr& 938 operator=(const weak_ptr<_Tp1>& __r) // never throws 939 { 940 this->__weak_ptr<_Tp>::operator=(__r); 941 return *this; 942 } 943 944 template<typename _Tp1> 945 weak_ptr& 946 operator=(const shared_ptr<_Tp1>& __r) // never throws 947 { 948 this->__weak_ptr<_Tp>::operator=(__r); 949 return *this; 950 } 951 952 shared_ptr<_Tp> 953 lock() const // never throws 954 { 955 #ifdef __GTHREADS 956 if (this->expired()) 957 return shared_ptr<_Tp>(); 958 959 __try 960 { 961 return shared_ptr<_Tp>(*this); 962 } 963 __catch(const bad_weak_ptr&) 964 { 965 return shared_ptr<_Tp>(); 966 } 967 #else 968 return this->expired() ? shared_ptr<_Tp>() 969 : shared_ptr<_Tp>(*this); 970 #endif 971 } 972 }; 973 974 /// enable_shared_from_this 975 template<typename _Tp> 976 class enable_shared_from_this 977 { 978 protected: 979 enable_shared_from_this() { } 980 981 enable_shared_from_this(const enable_shared_from_this&) { } 982 983 enable_shared_from_this& 984 operator=(const enable_shared_from_this&) 985 { return *this; } 986 987 ~enable_shared_from_this() { } 988 989 public: 990 shared_ptr<_Tp> 991 shared_from_this() 992 { return shared_ptr<_Tp>(this->_M_weak_this); } 993 994 shared_ptr<const _Tp> 995 shared_from_this() const 996 { return shared_ptr<const _Tp>(this->_M_weak_this); } 997 998 private: 999 template<typename _Tp1> 1000 void 1001 _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const 1002 { _M_weak_this._M_assign(__p, __n); } 1003 1004 template<typename _Tp1> 1005 friend void 1006 __enable_shared_from_this_helper(const __shared_count<>& __pn, 1007 const enable_shared_from_this* __pe, 1008 const _Tp1* __px) 1009 { 1010 if (__pe != 0) 1011 __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); 1012 } 1013 1014 mutable weak_ptr<_Tp> _M_weak_this; 1015 }; 1016 1017 } 1018 } 1019 1020 #endif // _TR1_SHARED_PTR_H 1021
