1 | #ifndef BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED |
2 | #define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED |
3 | |
4 | // MS compatible compilers support #pragma once |
5 | |
6 | #if defined(_MSC_VER) && (_MSC_VER >= 1020) |
7 | # pragma once |
8 | #endif |
9 | |
10 | // |
11 | // detail/shared_count.hpp |
12 | // |
13 | // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. |
14 | // Copyright 2004-2005 Peter Dimov |
15 | // |
16 | // Distributed under the Boost Software License, Version 1.0. (See |
17 | // accompanying file LICENSE_1_0.txt or copy at |
18 | // http://www.boost.org/LICENSE_1_0.txt) |
19 | // |
20 | |
21 | #if defined(__BORLANDC__) && !defined(__clang__) |
22 | # pragma warn -8027 // Functions containing try are not expanded inline |
23 | #endif |
24 | |
25 | #include <boost/smart_ptr/bad_weak_ptr.hpp> |
26 | #include <boost/smart_ptr/detail/sp_counted_base.hpp> |
27 | #include <boost/smart_ptr/detail/sp_counted_impl.hpp> |
28 | #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp> |
29 | #include <boost/smart_ptr/detail/sp_noexcept.hpp> |
30 | #include <boost/checked_delete.hpp> |
31 | #include <boost/throw_exception.hpp> |
32 | #include <boost/core/addressof.hpp> |
33 | #include <boost/config.hpp> |
34 | #include <boost/config/workaround.hpp> |
35 | #include <boost/cstdint.hpp> |
36 | #include <memory> // std::auto_ptr |
37 | #include <functional> // std::less |
38 | #include <cstddef> // std::size_t |
39 | |
40 | #ifdef BOOST_NO_EXCEPTIONS |
41 | # include <new> // std::bad_alloc |
42 | #endif |
43 | |
44 | #if defined( BOOST_SP_DISABLE_DEPRECATED ) |
45 | #pragma GCC diagnostic push |
46 | #pragma GCC diagnostic ignored "-Wdeprecated-declarations" |
47 | #endif |
48 | |
49 | namespace boost |
50 | { |
51 | |
52 | namespace movelib |
53 | { |
54 | |
55 | template< class T, class D > class unique_ptr; |
56 | |
57 | } // namespace movelib |
58 | |
59 | namespace detail |
60 | { |
61 | |
62 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
63 | |
64 | int const shared_count_id = 0x2C35F101; |
65 | int const weak_count_id = 0x298C38A4; |
66 | |
67 | #endif |
68 | |
69 | struct sp_nothrow_tag {}; |
70 | |
71 | template< class D > struct sp_inplace_tag |
72 | { |
73 | }; |
74 | |
75 | template< class T > class sp_reference_wrapper |
76 | { |
77 | public: |
78 | |
79 | explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) ) |
80 | { |
81 | } |
82 | |
83 | template< class Y > void operator()( Y * p ) const |
84 | { |
85 | (*t_)( p ); |
86 | } |
87 | |
88 | private: |
89 | |
90 | T * t_; |
91 | }; |
92 | |
93 | template< class D > struct sp_convert_reference |
94 | { |
95 | typedef D type; |
96 | }; |
97 | |
98 | template< class D > struct sp_convert_reference< D& > |
99 | { |
100 | typedef sp_reference_wrapper< D > type; |
101 | }; |
102 | |
103 | template<class T> std::size_t sp_hash_pointer( T* p ) BOOST_NOEXCEPT |
104 | { |
105 | boost::uintptr_t v = reinterpret_cast<boost::uintptr_t>( p ); |
106 | |
107 | // match boost::hash<T*> |
108 | return static_cast<std::size_t>( v + ( v >> 3 ) ); |
109 | } |
110 | |
111 | class weak_count; |
112 | |
113 | class shared_count |
114 | { |
115 | private: |
116 | |
117 | sp_counted_base * pi_; |
118 | |
119 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
120 | int id_; |
121 | #endif |
122 | |
123 | friend class weak_count; |
124 | |
125 | public: |
126 | |
127 | BOOST_CONSTEXPR shared_count() BOOST_SP_NOEXCEPT: pi_(0) |
128 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
129 | , id_(shared_count_id) |
130 | #endif |
131 | { |
132 | } |
133 | |
134 | BOOST_CONSTEXPR explicit shared_count( sp_counted_base * pi ) BOOST_SP_NOEXCEPT: pi_( pi ) |
135 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
136 | , id_(shared_count_id) |
137 | #endif |
138 | { |
139 | } |
140 | |
141 | template<class Y> explicit shared_count( Y * p ): pi_( 0 ) |
142 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
143 | , id_(shared_count_id) |
144 | #endif |
145 | { |
146 | #ifndef BOOST_NO_EXCEPTIONS |
147 | |
148 | try |
149 | { |
150 | pi_ = new sp_counted_impl_p<Y>( p ); |
151 | } |
152 | catch(...) |
153 | { |
154 | boost::checked_delete( p ); |
155 | throw; |
156 | } |
157 | |
158 | #else |
159 | |
160 | pi_ = new sp_counted_impl_p<Y>( p ); |
161 | |
162 | if( pi_ == 0 ) |
163 | { |
164 | boost::checked_delete( p ); |
165 | boost::throw_exception( std::bad_alloc() ); |
166 | } |
167 | |
168 | #endif |
169 | } |
170 | |
171 | #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) |
172 | template<class Y, class D> shared_count( Y * p, D d ): pi_(0) |
173 | #else |
174 | template<class P, class D> shared_count( P p, D d ): pi_(0) |
175 | #endif |
176 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
177 | , id_(shared_count_id) |
178 | #endif |
179 | { |
180 | #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) |
181 | typedef Y* P; |
182 | #endif |
183 | #ifndef BOOST_NO_EXCEPTIONS |
184 | |
185 | try |
186 | { |
187 | pi_ = new sp_counted_impl_pd<P, D>(p, d); |
188 | } |
189 | catch(...) |
190 | { |
191 | d(p); // delete p |
192 | throw; |
193 | } |
194 | |
195 | #else |
196 | |
197 | pi_ = new sp_counted_impl_pd<P, D>(p, d); |
198 | |
199 | if(pi_ == 0) |
200 | { |
201 | d(p); // delete p |
202 | boost::throw_exception(std::bad_alloc()); |
203 | } |
204 | |
205 | #endif |
206 | } |
207 | |
208 | #if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING ) |
209 | |
210 | template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 ) |
211 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
212 | , id_(shared_count_id) |
213 | #endif |
214 | { |
215 | #ifndef BOOST_NO_EXCEPTIONS |
216 | |
217 | try |
218 | { |
219 | pi_ = new sp_counted_impl_pd< P, D >( p ); |
220 | } |
221 | catch( ... ) |
222 | { |
223 | D::operator_fn( p ); // delete p |
224 | throw; |
225 | } |
226 | |
227 | #else |
228 | |
229 | pi_ = new sp_counted_impl_pd< P, D >( p ); |
230 | |
231 | if( pi_ == 0 ) |
232 | { |
233 | D::operator_fn( p ); // delete p |
234 | boost::throw_exception( std::bad_alloc() ); |
235 | } |
236 | |
237 | #endif // #ifndef BOOST_NO_EXCEPTIONS |
238 | } |
239 | |
240 | #endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING ) |
241 | |
242 | template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 ) |
243 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
244 | , id_(shared_count_id) |
245 | #endif |
246 | { |
247 | typedef sp_counted_impl_pda<P, D, A> impl_type; |
248 | |
249 | #if !defined( BOOST_NO_CXX11_ALLOCATOR ) |
250 | |
251 | typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2; |
252 | |
253 | #else |
254 | |
255 | typedef typename A::template rebind< impl_type >::other A2; |
256 | |
257 | #endif |
258 | |
259 | A2 a2( a ); |
260 | |
261 | #ifndef BOOST_NO_EXCEPTIONS |
262 | |
263 | try |
264 | { |
265 | pi_ = a2.allocate( 1 ); |
266 | ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a ); |
267 | } |
268 | catch(...) |
269 | { |
270 | d( p ); |
271 | |
272 | if( pi_ != 0 ) |
273 | { |
274 | a2.deallocate( static_cast< impl_type* >( pi_ ), 1 ); |
275 | } |
276 | |
277 | throw; |
278 | } |
279 | |
280 | #else |
281 | |
282 | pi_ = a2.allocate( 1 ); |
283 | |
284 | if( pi_ != 0 ) |
285 | { |
286 | ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a ); |
287 | } |
288 | else |
289 | { |
290 | d( p ); |
291 | boost::throw_exception( std::bad_alloc() ); |
292 | } |
293 | |
294 | #endif |
295 | } |
296 | |
297 | #if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING ) |
298 | |
299 | template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 ) |
300 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
301 | , id_(shared_count_id) |
302 | #endif |
303 | { |
304 | typedef sp_counted_impl_pda< P, D, A > impl_type; |
305 | |
306 | #if !defined( BOOST_NO_CXX11_ALLOCATOR ) |
307 | |
308 | typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2; |
309 | |
310 | #else |
311 | |
312 | typedef typename A::template rebind< impl_type >::other A2; |
313 | |
314 | #endif |
315 | |
316 | A2 a2( a ); |
317 | |
318 | #ifndef BOOST_NO_EXCEPTIONS |
319 | |
320 | try |
321 | { |
322 | pi_ = a2.allocate( 1 ); |
323 | ::new( static_cast< void* >( pi_ ) ) impl_type( p, a ); |
324 | } |
325 | catch(...) |
326 | { |
327 | D::operator_fn( p ); |
328 | |
329 | if( pi_ != 0 ) |
330 | { |
331 | a2.deallocate( static_cast< impl_type* >( pi_ ), 1 ); |
332 | } |
333 | |
334 | throw; |
335 | } |
336 | |
337 | #else |
338 | |
339 | pi_ = a2.allocate( 1 ); |
340 | |
341 | if( pi_ != 0 ) |
342 | { |
343 | ::new( static_cast< void* >( pi_ ) ) impl_type( p, a ); |
344 | } |
345 | else |
346 | { |
347 | D::operator_fn( p ); |
348 | boost::throw_exception( std::bad_alloc() ); |
349 | } |
350 | |
351 | #endif // #ifndef BOOST_NO_EXCEPTIONS |
352 | } |
353 | |
354 | #endif // !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING ) |
355 | |
356 | #ifndef BOOST_NO_AUTO_PTR |
357 | |
358 | // auto_ptr<Y> is special cased to provide the strong guarantee |
359 | |
360 | template<class Y> |
361 | explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) ) |
362 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
363 | , id_(shared_count_id) |
364 | #endif |
365 | { |
366 | #ifdef BOOST_NO_EXCEPTIONS |
367 | |
368 | if( pi_ == 0 ) |
369 | { |
370 | boost::throw_exception(std::bad_alloc()); |
371 | } |
372 | |
373 | #endif |
374 | |
375 | r.release(); |
376 | } |
377 | |
378 | #endif |
379 | |
380 | #if !defined( BOOST_NO_CXX11_SMART_PTR ) |
381 | |
382 | template<class Y, class D> |
383 | explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 ) |
384 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
385 | , id_(shared_count_id) |
386 | #endif |
387 | { |
388 | typedef typename sp_convert_reference<D>::type D2; |
389 | |
390 | D2 d2( r.get_deleter() ); |
391 | pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 ); |
392 | |
393 | #ifdef BOOST_NO_EXCEPTIONS |
394 | |
395 | if( pi_ == 0 ) |
396 | { |
397 | boost::throw_exception( std::bad_alloc() ); |
398 | } |
399 | |
400 | #endif |
401 | |
402 | r.release(); |
403 | } |
404 | |
405 | #endif |
406 | |
407 | template<class Y, class D> |
408 | explicit shared_count( boost::movelib::unique_ptr<Y, D> & r ): pi_( 0 ) |
409 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
410 | , id_(shared_count_id) |
411 | #endif |
412 | { |
413 | typedef typename sp_convert_reference<D>::type D2; |
414 | |
415 | D2 d2( r.get_deleter() ); |
416 | pi_ = new sp_counted_impl_pd< typename boost::movelib::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 ); |
417 | |
418 | #ifdef BOOST_NO_EXCEPTIONS |
419 | |
420 | if( pi_ == 0 ) |
421 | { |
422 | boost::throw_exception( std::bad_alloc() ); |
423 | } |
424 | |
425 | #endif |
426 | |
427 | r.release(); |
428 | } |
429 | |
430 | ~shared_count() /*BOOST_SP_NOEXCEPT*/ |
431 | { |
432 | if( pi_ != 0 ) pi_->release(); |
433 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
434 | id_ = 0; |
435 | #endif |
436 | } |
437 | |
438 | shared_count(shared_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_) |
439 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
440 | , id_(shared_count_id) |
441 | #endif |
442 | { |
443 | if( pi_ != 0 ) pi_->add_ref_copy(); |
444 | } |
445 | |
446 | #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) |
447 | |
448 | shared_count(shared_count && r) BOOST_SP_NOEXCEPT: pi_(r.pi_) |
449 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
450 | , id_(shared_count_id) |
451 | #endif |
452 | { |
453 | r.pi_ = 0; |
454 | } |
455 | |
456 | #endif |
457 | |
458 | explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0 |
459 | shared_count( weak_count const & r, sp_nothrow_tag ) BOOST_SP_NOEXCEPT; // constructs an empty *this when r.use_count() == 0 |
460 | |
461 | shared_count & operator= (shared_count const & r) BOOST_SP_NOEXCEPT |
462 | { |
463 | sp_counted_base * tmp = r.pi_; |
464 | |
465 | if( tmp != pi_ ) |
466 | { |
467 | if( tmp != 0 ) tmp->add_ref_copy(); |
468 | if( pi_ != 0 ) pi_->release(); |
469 | pi_ = tmp; |
470 | } |
471 | |
472 | return *this; |
473 | } |
474 | |
475 | void swap(shared_count & r) BOOST_SP_NOEXCEPT |
476 | { |
477 | sp_counted_base * tmp = r.pi_; |
478 | r.pi_ = pi_; |
479 | pi_ = tmp; |
480 | } |
481 | |
482 | long use_count() const BOOST_SP_NOEXCEPT |
483 | { |
484 | return pi_ != 0? pi_->use_count(): 0; |
485 | } |
486 | |
487 | bool unique() const BOOST_SP_NOEXCEPT |
488 | { |
489 | return use_count() == 1; |
490 | } |
491 | |
492 | bool empty() const BOOST_SP_NOEXCEPT |
493 | { |
494 | return pi_ == 0; |
495 | } |
496 | |
497 | bool operator==( shared_count const & r ) const BOOST_SP_NOEXCEPT |
498 | { |
499 | return pi_ == r.pi_; |
500 | } |
501 | |
502 | bool operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT; |
503 | |
504 | bool operator<( shared_count const & r ) const BOOST_SP_NOEXCEPT |
505 | { |
506 | return std::less<sp_counted_base *>()( pi_, r.pi_ ); |
507 | } |
508 | |
509 | bool operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT; |
510 | |
511 | void * get_deleter( sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT |
512 | { |
513 | return pi_? pi_->get_deleter( ti ): 0; |
514 | } |
515 | |
516 | void * get_local_deleter( sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT |
517 | { |
518 | return pi_? pi_->get_local_deleter( ti ): 0; |
519 | } |
520 | |
521 | void * get_untyped_deleter() const BOOST_SP_NOEXCEPT |
522 | { |
523 | return pi_? pi_->get_untyped_deleter(): 0; |
524 | } |
525 | |
526 | std::size_t hash_value() const BOOST_SP_NOEXCEPT |
527 | { |
528 | return sp_hash_pointer( p: pi_ ); |
529 | } |
530 | }; |
531 | |
532 | |
533 | class weak_count |
534 | { |
535 | private: |
536 | |
537 | sp_counted_base * pi_; |
538 | |
539 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
540 | int id_; |
541 | #endif |
542 | |
543 | friend class shared_count; |
544 | |
545 | public: |
546 | |
547 | BOOST_CONSTEXPR weak_count() BOOST_SP_NOEXCEPT: pi_(0) |
548 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
549 | , id_(weak_count_id) |
550 | #endif |
551 | { |
552 | } |
553 | |
554 | weak_count(shared_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_) |
555 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
556 | , id_(weak_count_id) |
557 | #endif |
558 | { |
559 | if(pi_ != 0) pi_->weak_add_ref(); |
560 | } |
561 | |
562 | weak_count(weak_count const & r) BOOST_SP_NOEXCEPT: pi_(r.pi_) |
563 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
564 | , id_(weak_count_id) |
565 | #endif |
566 | { |
567 | if(pi_ != 0) pi_->weak_add_ref(); |
568 | } |
569 | |
570 | // Move support |
571 | |
572 | #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) |
573 | |
574 | weak_count(weak_count && r) BOOST_SP_NOEXCEPT: pi_(r.pi_) |
575 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
576 | , id_(weak_count_id) |
577 | #endif |
578 | { |
579 | r.pi_ = 0; |
580 | } |
581 | |
582 | #endif |
583 | |
584 | ~weak_count() /*BOOST_SP_NOEXCEPT*/ |
585 | { |
586 | if(pi_ != 0) pi_->weak_release(); |
587 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
588 | id_ = 0; |
589 | #endif |
590 | } |
591 | |
592 | weak_count & operator= (shared_count const & r) BOOST_SP_NOEXCEPT |
593 | { |
594 | sp_counted_base * tmp = r.pi_; |
595 | |
596 | if( tmp != pi_ ) |
597 | { |
598 | if(tmp != 0) tmp->weak_add_ref(); |
599 | if(pi_ != 0) pi_->weak_release(); |
600 | pi_ = tmp; |
601 | } |
602 | |
603 | return *this; |
604 | } |
605 | |
606 | weak_count & operator= (weak_count const & r) BOOST_SP_NOEXCEPT |
607 | { |
608 | sp_counted_base * tmp = r.pi_; |
609 | |
610 | if( tmp != pi_ ) |
611 | { |
612 | if(tmp != 0) tmp->weak_add_ref(); |
613 | if(pi_ != 0) pi_->weak_release(); |
614 | pi_ = tmp; |
615 | } |
616 | |
617 | return *this; |
618 | } |
619 | |
620 | void swap(weak_count & r) BOOST_SP_NOEXCEPT |
621 | { |
622 | sp_counted_base * tmp = r.pi_; |
623 | r.pi_ = pi_; |
624 | pi_ = tmp; |
625 | } |
626 | |
627 | long use_count() const BOOST_SP_NOEXCEPT |
628 | { |
629 | return pi_ != 0? pi_->use_count(): 0; |
630 | } |
631 | |
632 | bool empty() const BOOST_SP_NOEXCEPT |
633 | { |
634 | return pi_ == 0; |
635 | } |
636 | |
637 | bool operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT |
638 | { |
639 | return pi_ == r.pi_; |
640 | } |
641 | |
642 | bool operator==( shared_count const & r ) const BOOST_SP_NOEXCEPT |
643 | { |
644 | return pi_ == r.pi_; |
645 | } |
646 | |
647 | bool operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT |
648 | { |
649 | return std::less<sp_counted_base *>()( pi_, r.pi_ ); |
650 | } |
651 | |
652 | bool operator<( shared_count const & r ) const BOOST_SP_NOEXCEPT |
653 | { |
654 | return std::less<sp_counted_base *>()( pi_, r.pi_ ); |
655 | } |
656 | |
657 | std::size_t hash_value() const BOOST_SP_NOEXCEPT |
658 | { |
659 | return sp_hash_pointer( p: pi_ ); |
660 | } |
661 | }; |
662 | |
663 | inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ ) |
664 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
665 | , id_(shared_count_id) |
666 | #endif |
667 | { |
668 | if( pi_ == 0 || !pi_->add_ref_lock() ) |
669 | { |
670 | boost::throw_exception( e: boost::bad_weak_ptr() ); |
671 | } |
672 | } |
673 | |
674 | inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ) BOOST_SP_NOEXCEPT: pi_( r.pi_ ) |
675 | #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) |
676 | , id_(shared_count_id) |
677 | #endif |
678 | { |
679 | if( pi_ != 0 && !pi_->add_ref_lock() ) |
680 | { |
681 | pi_ = 0; |
682 | } |
683 | } |
684 | |
685 | inline bool shared_count::operator==( weak_count const & r ) const BOOST_SP_NOEXCEPT |
686 | { |
687 | return pi_ == r.pi_; |
688 | } |
689 | |
690 | inline bool shared_count::operator<( weak_count const & r ) const BOOST_SP_NOEXCEPT |
691 | { |
692 | return std::less<sp_counted_base *>()( pi_, r.pi_ ); |
693 | } |
694 | |
695 | } // namespace detail |
696 | |
697 | } // namespace boost |
698 | |
699 | #if defined( BOOST_SP_DISABLE_DEPRECATED ) |
700 | #pragma GCC diagnostic pop |
701 | #endif |
702 | |
703 | #if defined(__BORLANDC__) && !defined(__clang__) |
704 | # pragma warn .8027 // Functions containing try are not expanded inline |
705 | #endif |
706 | |
707 | #endif // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED |
708 | |