1#ifndef BOOST_THREAD_THREAD_COMMON_HPP
2#define BOOST_THREAD_THREAD_COMMON_HPP
3// Distributed under the Boost Software License, Version 1.0. (See
4// accompanying file LICENSE_1_0.txt or copy at
5// http://www.boost.org/LICENSE_1_0.txt)
6// (C) Copyright 2007-2010 Anthony Williams
7// (C) Copyright 2011-2012 Vicente J. Botet Escriba
8
9#include <boost/thread/detail/config.hpp>
10#include <boost/predef/platform.h>
11
12#include <boost/thread/exceptions.hpp>
13#ifndef BOOST_NO_IOSTREAM
14#include <ostream>
15#endif
16#include <boost/thread/detail/move.hpp>
17#include <boost/thread/mutex.hpp>
18#if defined BOOST_THREAD_USES_DATETIME
19#include <boost/thread/xtime.hpp>
20#endif
21#include <boost/thread/detail/thread_heap_alloc.hpp>
22#include <boost/thread/detail/make_tuple_indices.hpp>
23#include <boost/thread/detail/invoke.hpp>
24#include <boost/thread/detail/is_convertible.hpp>
25#include <boost/assert.hpp>
26#include <list>
27#include <algorithm>
28#include <boost/core/ref.hpp>
29#include <boost/cstdint.hpp>
30#include <boost/bind.hpp>
31#include <stdlib.h>
32#include <memory>
33#include <boost/core/enable_if.hpp>
34#include <boost/type_traits/remove_reference.hpp>
35#include <boost/io/ios_state.hpp>
36#include <boost/type_traits/is_same.hpp>
37#include <boost/type_traits/decay.hpp>
38#include <boost/functional/hash.hpp>
39#ifdef BOOST_THREAD_USES_CHRONO
40#include <boost/chrono/system_clocks.hpp>
41#include <boost/chrono/ceil.hpp>
42#endif
43
44#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
45#include <tuple>
46#endif
47#include <boost/config/abi_prefix.hpp>
48
49#ifdef BOOST_MSVC
50#pragma warning(push)
51#pragma warning(disable:4251)
52#endif
53
54namespace boost
55{
56
57 namespace detail
58 {
59
60#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
61
62 template<typename F, class ...ArgTypes>
63 class thread_data:
64 public detail::thread_data_base
65 {
66 public:
67 BOOST_THREAD_NO_COPYABLE(thread_data)
68 thread_data(BOOST_THREAD_RV_REF(F) f_, BOOST_THREAD_RV_REF(ArgTypes)... args_):
69 fp(boost::forward<F>(f_), boost::forward<ArgTypes>(args_)...)
70 {}
71 template <std::size_t ...Indices>
72 void run2(tuple_indices<Indices...>)
73 {
74
75 detail::invoke(std::move(std::get<0>(fp)), std::move(std::get<Indices>(fp))...);
76 }
77 void run()
78 {
79 typedef typename make_tuple_indices<std::tuple_size<std::tuple<F, ArgTypes...> >::value, 1>::type index_type;
80
81 run2(index_type());
82 }
83
84 private:
85 std::tuple<typename decay<F>::type, typename decay<ArgTypes>::type...> fp;
86 };
87#else // defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
88
89 template<typename F>
90 class thread_data:
91 public detail::thread_data_base
92 {
93 public:
94 BOOST_THREAD_NO_COPYABLE(thread_data)
95#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
96 thread_data(BOOST_THREAD_RV_REF(F) f_):
97 f(boost::forward<F>(f_))
98 {}
99// This overloading must be removed if we want the packaged_task's tests to pass.
100// thread_data(F& f_):
101// f(f_)
102// {}
103#else
104
105 thread_data(BOOST_THREAD_RV_REF(F) f_):
106 f(f_)
107 {}
108 thread_data(F f_):
109 f(f_)
110 {}
111#endif
112 //thread_data() {}
113
114 void run()
115 {
116 f();
117 }
118
119 private:
120 F f;
121 };
122
123 template<typename F>
124 class thread_data<boost::reference_wrapper<F> >:
125 public detail::thread_data_base
126 {
127 private:
128 F& f;
129 public:
130 BOOST_THREAD_NO_COPYABLE(thread_data)
131 thread_data(boost::reference_wrapper<F> f_):
132 f(f_)
133 {}
134 void run()
135 {
136 f();
137 }
138 };
139
140 template<typename F>
141 class thread_data<const boost::reference_wrapper<F> >:
142 public detail::thread_data_base
143 {
144 private:
145 F& f;
146 public:
147 BOOST_THREAD_NO_COPYABLE(thread_data)
148 thread_data(const boost::reference_wrapper<F> f_):
149 f(f_)
150 {}
151 void run()
152 {
153 f();
154 }
155 };
156#endif
157 }
158namespace thread_detail {
159#ifdef BOOST_THREAD_USES_CHRONO
160#if defined(BOOST_THREAD_HAS_CONDATTR_SET_CLOCK_MONOTONIC) && defined(BOOST_THREAD_USEFIXES_TIMESPEC)
161 typedef chrono::steady_clock internal_clock_t;
162#else
163 typedef chrono::system_clock internal_clock_t;
164#endif
165#endif
166}
167 class BOOST_THREAD_DECL thread
168 {
169 public:
170 typedef thread_attributes attributes;
171
172 BOOST_THREAD_MOVABLE_ONLY(thread)
173 private:
174
175 struct dummy;
176
177 void release_handle();
178
179 detail::thread_data_ptr thread_info;
180
181 private:
182 bool start_thread_noexcept();
183 bool start_thread_noexcept(const attributes& attr);
184 void start_thread()
185 {
186 if (!start_thread_noexcept())
187 {
188 boost::throw_exception(thread_resource_error());
189 }
190 }
191 void start_thread(const attributes& attr)
192 {
193 if (!start_thread_noexcept(attr))
194 {
195 boost::throw_exception(thread_resource_error());
196 }
197 }
198
199 explicit thread(detail::thread_data_ptr data);
200
201 detail::thread_data_ptr get_thread_info BOOST_PREVENT_MACRO_SUBSTITUTION () const;
202
203#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
204#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
205 template<typename F, class ...ArgTypes>
206 static inline detail::thread_data_ptr make_thread_info(BOOST_THREAD_RV_REF(F) f, BOOST_THREAD_RV_REF(ArgTypes)... args)
207 {
208 return detail::thread_data_ptr(detail::heap_new<
209 detail::thread_data<typename boost::remove_reference<F>::type, ArgTypes...>
210 >(
211 boost::forward<F>(f), boost::forward<ArgTypes>(args)...
212 )
213 );
214 }
215#else
216 template<typename F>
217 static inline detail::thread_data_ptr make_thread_info(BOOST_THREAD_RV_REF(F) f)
218 {
219 return detail::thread_data_ptr(detail::heap_new<detail::thread_data<typename boost::remove_reference<F>::type> >(
220 boost::forward<F>(f)));
221 }
222#endif
223 static inline detail::thread_data_ptr make_thread_info(void (*f)())
224 {
225 return detail::thread_data_ptr(detail::heap_new<detail::thread_data<void(*)()> >(
226 boost::forward<void(*)()>(f)));
227 }
228#else
229 template<typename F>
230 static inline detail::thread_data_ptr make_thread_info(F f
231 , typename disable_if_c<
232 //boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value ||
233 is_same<typename decay<F>::type, thread>::value,
234 dummy* >::type=0
235 )
236 {
237 return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
238 }
239 template<typename F>
240 static inline detail::thread_data_ptr make_thread_info(BOOST_THREAD_RV_REF(F) f)
241 {
242 return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
243 }
244
245#endif
246 public:
247#if 0 // This should not be needed anymore. Use instead BOOST_THREAD_MAKE_RV_REF.
248#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
249 thread(const volatile thread&);
250#endif
251#endif
252 thread() BOOST_NOEXCEPT;
253 ~thread()
254 {
255
256 #if defined BOOST_THREAD_PROVIDES_THREAD_DESTRUCTOR_CALLS_TERMINATE_IF_JOINABLE
257 if (joinable()) {
258 std::terminate();
259 }
260 #else
261 detach();
262 #endif
263 }
264#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
265 template <
266 class F
267 >
268 explicit thread(BOOST_THREAD_RV_REF(F) f
269 //, typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0
270 ):
271 thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f))))
272 {
273 start_thread();
274 }
275 template <
276 class F
277 >
278 thread(attributes const& attrs, BOOST_THREAD_RV_REF(F) f):
279 thread_info(make_thread_info(thread_detail::decay_copy(boost::forward<F>(f))))
280 {
281 start_thread(attrs);
282 }
283
284#else
285#ifdef BOOST_NO_SFINAE
286 template <class F>
287 explicit thread(F f):
288 thread_info(make_thread_info(f))
289 {
290 start_thread();
291 }
292 template <class F>
293 thread(attributes const& attrs, F f):
294 thread_info(make_thread_info(f))
295 {
296 start_thread(attrs);
297 }
298#else
299 template <class F>
300 explicit thread(F f
301 , typename disable_if_c<
302 boost::thread_detail::is_rv<F>::value // todo ass a thread_detail::is_rv
303 //boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F)>::value
304 //|| is_same<typename decay<F>::type, thread>::value
305 , dummy* >::type=0
306 ):
307 thread_info(make_thread_info(f))
308 {
309 start_thread();
310 }
311 template <class F>
312 thread(attributes const& attrs, F f
313 , typename disable_if<boost::thread_detail::is_rv<F>, dummy* >::type=0
314 //, typename disable_if<boost::thread_detail::is_convertible<F&,BOOST_THREAD_RV_REF(F) >, dummy* >::type=0
315 ):
316 thread_info(make_thread_info(f))
317 {
318 start_thread(attrs);
319 }
320#endif
321 template <class F>
322 explicit thread(BOOST_THREAD_RV_REF(F) f
323 , typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0
324 ):
325#ifdef BOOST_THREAD_USES_MOVE
326 thread_info(make_thread_info(boost::move<F>(f))) // todo : Add forward
327#else
328 thread_info(make_thread_info(f)) // todo : Add forward
329#endif
330 {
331 start_thread();
332 }
333
334 template <class F>
335 thread(attributes const& attrs, BOOST_THREAD_RV_REF(F) f):
336#ifdef BOOST_THREAD_USES_MOVE
337 thread_info(make_thread_info(boost::move<F>(f))) // todo : Add forward
338#else
339 thread_info(make_thread_info(f)) // todo : Add forward
340#endif
341 {
342 start_thread(attrs);
343 }
344#endif
345 thread(BOOST_THREAD_RV_REF(thread) x) BOOST_NOEXCEPT
346 {
347 thread_info=BOOST_THREAD_RV(x).thread_info;
348 BOOST_THREAD_RV(x).thread_info.reset();
349 }
350#if 0 // This should not be needed anymore. Use instead BOOST_THREAD_MAKE_RV_REF.
351#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100)
352 thread& operator=(thread x)
353 {
354 swap(x);
355 return *this;
356 }
357#endif
358#endif
359
360 thread& operator=(BOOST_THREAD_RV_REF(thread) other) BOOST_NOEXCEPT
361 {
362
363#if defined BOOST_THREAD_PROVIDES_THREAD_MOVE_ASSIGN_CALLS_TERMINATE_IF_JOINABLE
364 if (joinable()) std::terminate();
365#else
366 detach();
367#endif
368 thread_info=BOOST_THREAD_RV(other).thread_info;
369 BOOST_THREAD_RV(other).thread_info.reset();
370 return *this;
371 }
372
373#if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
374 template <class F, class Arg, class ...Args>
375 thread(F&& f, Arg&& arg, Args&&... args) :
376 thread_info(make_thread_info(
377 thread_detail::decay_copy(boost::forward<F>(f)),
378 thread_detail::decay_copy(boost::forward<Arg>(arg)),
379 thread_detail::decay_copy(boost::forward<Args>(args))...)
380 )
381
382 {
383 start_thread();
384 }
385 template <class F, class Arg, class ...Args>
386 thread(attributes const& attrs, F&& f, Arg&& arg, Args&&... args) :
387 thread_info(make_thread_info(
388 thread_detail::decay_copy(boost::forward<F>(f)),
389 thread_detail::decay_copy(boost::forward<Arg>(arg)),
390 thread_detail::decay_copy(boost::forward<Args>(args))...)
391 )
392
393 {
394 start_thread(attrs);
395 }
396#else
397 template <class F,class A1>
398 thread(F f,A1 a1,typename disable_if<boost::thread_detail::is_convertible<F&,thread_attributes >, dummy* >::type=0):
399 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
400 {
401 start_thread();
402 }
403 template <class F,class A1,class A2>
404 thread(F f,A1 a1,A2 a2):
405 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))
406 {
407 start_thread();
408 }
409
410 template <class F,class A1,class A2,class A3>
411 thread(F f,A1 a1,A2 a2,A3 a3):
412 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))
413 {
414 start_thread();
415 }
416
417 template <class F,class A1,class A2,class A3,class A4>
418 thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):
419 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))
420 {
421 start_thread();
422 }
423
424 template <class F,class A1,class A2,class A3,class A4,class A5>
425 thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):
426 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))
427 {
428 start_thread();
429 }
430
431 template <class F,class A1,class A2,class A3,class A4,class A5,class A6>
432 thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):
433 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))
434 {
435 start_thread();
436 }
437
438 template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
439 thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):
440 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))
441 {
442 start_thread();
443 }
444
445 template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
446 thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):
447 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))
448 {
449 start_thread();
450 }
451
452 template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
453 thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):
454 thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))
455 {
456 start_thread();
457 }
458#endif
459 void swap(thread& x) BOOST_NOEXCEPT
460 {
461 thread_info.swap(x.thread_info);
462 }
463
464 class id;
465#ifdef BOOST_THREAD_PLATFORM_PTHREAD
466 inline id get_id() const BOOST_NOEXCEPT;
467#else
468 id get_id() const BOOST_NOEXCEPT;
469#endif
470
471
472 bool joinable() const BOOST_NOEXCEPT;
473 private:
474 bool join_noexcept();
475 public:
476 inline void join();
477
478#ifdef BOOST_THREAD_USES_CHRONO
479#if defined(BOOST_THREAD_PLATFORM_WIN32)
480 template <class Rep, class Period>
481 bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
482 {
483 chrono::milliseconds rel_time2= chrono::ceil<chrono::milliseconds>(rel_time);
484 return do_try_join_until(rel_time2.count());
485 }
486#else
487 template <class Rep, class Period>
488 bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
489 {
490 return try_join_until(chrono::steady_clock::now() + rel_time);
491 }
492#endif
493
494 template <class Clock, class Duration>
495 bool try_join_until(const chrono::time_point<Clock, Duration>& t)
496 {
497 using namespace chrono;
498 bool joined= false;
499 do {
500 thread_detail::internal_clock_t::time_point s_now = thread_detail::internal_clock_t::now();
501 typename Clock::duration d = ceil<nanoseconds>(t-Clock::now());
502 if (d <= Clock::duration::zero()) return false; // in case the Clock::time_point t is already reached
503 joined = try_join_until(s_now + d);
504 } while (! joined);
505 return true;
506 }
507 template <class Duration>
508 bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, Duration>& t)
509 {
510 using namespace chrono;
511 typedef time_point<thread_detail::internal_clock_t, nanoseconds> nano_sys_tmpt;
512 return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
513 }
514#endif
515#if defined(BOOST_THREAD_PLATFORM_WIN32)
516 private:
517 bool do_try_join_until_noexcept(uintmax_t milli, bool& res);
518 inline bool do_try_join_until(uintmax_t milli);
519 public:
520 bool timed_join(const system_time& abs_time);
521 //{
522 // return do_try_join_until(get_milliseconds_until(wait_until));
523 //}
524
525#ifdef BOOST_THREAD_USES_CHRONO
526 bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, chrono::nanoseconds>& tp)
527 {
528 chrono::milliseconds rel_time= chrono::ceil<chrono::milliseconds>(tp-chrono::system_clock::now());
529 return do_try_join_until(rel_time.count());
530 }
531#endif
532
533
534#else
535 private:
536 bool do_try_join_until_noexcept(struct timespec const &timeout, bool& res);
537 inline bool do_try_join_until(struct timespec const &timeout);
538 public:
539#if defined BOOST_THREAD_USES_DATETIME
540 bool timed_join(const system_time& abs_time)
541 {
542 struct timespec const ts=detail::to_timespec(abs_time);
543 return do_try_join_until(ts);
544 }
545#endif
546#ifdef BOOST_THREAD_USES_CHRONO
547 bool try_join_until(const chrono::time_point<thread_detail::internal_clock_t, chrono::nanoseconds>& tp)
548 {
549 using namespace chrono;
550 nanoseconds d = tp.time_since_epoch();
551 timespec ts = boost::detail::to_timespec(d);
552 return do_try_join_until(ts);
553 }
554#endif
555
556#endif
557 public:
558
559#if defined BOOST_THREAD_USES_DATETIME
560 template<typename TimeDuration>
561 inline bool timed_join(TimeDuration const& rel_time)
562 {
563 return timed_join(get_system_time()+rel_time);
564 }
565#endif
566 void detach();
567
568 static unsigned hardware_concurrency() BOOST_NOEXCEPT;
569 static unsigned physical_concurrency() BOOST_NOEXCEPT;
570
571#define BOOST_THREAD_DEFINES_THREAD_NATIVE_HANDLE
572 typedef detail::thread_data_base::native_handle_type native_handle_type;
573 native_handle_type native_handle();
574
575#if defined BOOST_THREAD_PROVIDES_THREAD_EQ
576 // Use thread::id when comparisions are needed
577 // backwards compatibility
578 bool operator==(const thread& other) const;
579 bool operator!=(const thread& other) const;
580#endif
581#if defined BOOST_THREAD_USES_DATETIME
582 static inline void yield() BOOST_NOEXCEPT
583 {
584 this_thread::yield();
585 }
586
587 static inline void sleep(const system_time& xt)
588 {
589 this_thread::sleep(xt);
590 }
591#endif
592
593#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
594 // extensions
595 void interrupt();
596 bool interruption_requested() const BOOST_NOEXCEPT;
597#endif
598 };
599
600 inline void swap(thread& lhs,thread& rhs) BOOST_NOEXCEPT
601 {
602 return lhs.swap(rhs);
603 }
604
605#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
606 inline thread&& move(thread& t) BOOST_NOEXCEPT
607 {
608 return static_cast<thread&&>(t);
609 }
610#endif
611
612 BOOST_THREAD_DCL_MOVABLE(thread)
613
614 namespace this_thread
615 {
616#ifdef BOOST_THREAD_PLATFORM_PTHREAD
617 inline thread::id get_id() BOOST_NOEXCEPT;
618#else
619 thread::id BOOST_THREAD_DECL get_id() BOOST_NOEXCEPT;
620#endif
621
622#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
623 void BOOST_THREAD_DECL interruption_point();
624 bool BOOST_THREAD_DECL interruption_enabled() BOOST_NOEXCEPT;
625 bool BOOST_THREAD_DECL interruption_requested() BOOST_NOEXCEPT;
626#endif
627
628#if defined BOOST_THREAD_USES_DATETIME
629 inline BOOST_SYMBOL_VISIBLE void sleep(xtime const& abs_time)
630 {
631 sleep(system_time(abs_time));
632 }
633#endif
634 }
635
636 class BOOST_SYMBOL_VISIBLE thread::id
637 {
638 private:
639 friend inline
640 std::size_t
641 hash_value(const thread::id &v)
642 {
643#if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
644 return hash_value(v.thread_data);
645#else
646 return hash_value(v.thread_data.get());
647#endif
648 }
649
650#if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
651#if defined(BOOST_THREAD_PLATFORM_WIN32)
652 typedef unsigned int data;
653#else
654 typedef thread::native_handle_type data;
655#endif
656#else
657 typedef detail::thread_data_ptr data;
658#endif
659 data thread_data;
660
661 id(data thread_data_):
662 thread_data(thread_data_)
663 {}
664 friend class thread;
665 friend id BOOST_THREAD_DECL this_thread::get_id() BOOST_NOEXCEPT;
666 public:
667 id() BOOST_NOEXCEPT:
668#if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
669 thread_data(0)
670#else
671 thread_data()
672#endif
673 {}
674
675 id(const id& other) BOOST_NOEXCEPT :
676 thread_data(other.thread_data)
677 {}
678
679 bool operator==(const id& y) const BOOST_NOEXCEPT
680 {
681 return thread_data==y.thread_data;
682 }
683
684 bool operator!=(const id& y) const BOOST_NOEXCEPT
685 {
686 return thread_data!=y.thread_data;
687 }
688
689 bool operator<(const id& y) const BOOST_NOEXCEPT
690 {
691 return thread_data<y.thread_data;
692 }
693
694 bool operator>(const id& y) const BOOST_NOEXCEPT
695 {
696 return y.thread_data<thread_data;
697 }
698
699 bool operator<=(const id& y) const BOOST_NOEXCEPT
700 {
701 return !(y.thread_data<thread_data);
702 }
703
704 bool operator>=(const id& y) const BOOST_NOEXCEPT
705 {
706 return !(thread_data<y.thread_data);
707 }
708
709#ifndef BOOST_NO_IOSTREAM
710#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
711 template<class charT, class traits>
712 friend BOOST_SYMBOL_VISIBLE
713 std::basic_ostream<charT, traits>&
714 operator<<(std::basic_ostream<charT, traits>& os, const id& x)
715 {
716 if(x.thread_data)
717 {
718 io::ios_flags_saver ifs( os );
719 return os<< std::hex << x.thread_data;
720 }
721 else
722 {
723 return os<<"{Not-any-thread}";
724 }
725 }
726#else
727 template<class charT, class traits>
728 BOOST_SYMBOL_VISIBLE
729 std::basic_ostream<charT, traits>&
730 print(std::basic_ostream<charT, traits>& os) const
731 {
732 if(thread_data)
733 {
734 io::ios_flags_saver ifs( os );
735 return os<< std::hex << thread_data;
736 }
737 else
738 {
739 return os<<"{Not-any-thread}";
740 }
741 }
742
743#endif
744#endif
745 };
746
747#ifdef BOOST_THREAD_PLATFORM_PTHREAD
748 thread::id thread::get_id() const BOOST_NOEXCEPT
749 {
750 #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
751 return const_cast<thread*>(this)->native_handle();
752 #else
753 detail::thread_data_ptr const local_thread_info=(get_thread_info)();
754 return (local_thread_info? id(local_thread_info) : id());
755 #endif
756 }
757
758 namespace this_thread
759 {
760 inline thread::id get_id() BOOST_NOEXCEPT
761 {
762 #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID
763 return pthread_self();
764 #else
765 boost::detail::thread_data_base* const thread_info=get_or_make_current_thread_data();
766 return (thread_info?thread::id(thread_info->shared_from_this()):thread::id());
767 #endif
768 }
769 }
770#endif
771 void thread::join() {
772 if (this_thread::get_id() == get_id())
773 boost::throw_exception(thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost thread: trying joining itself"));
774
775 BOOST_THREAD_VERIFY_PRECONDITION( join_noexcept(),
776 thread_resource_error(static_cast<int>(system::errc::invalid_argument), "boost thread: thread not joinable")
777 );
778 }
779
780#ifdef BOOST_THREAD_PLATFORM_PTHREAD
781 bool thread::do_try_join_until(struct timespec const &timeout)
782#else
783 bool thread::do_try_join_until(uintmax_t timeout)
784#endif
785 {
786 if (this_thread::get_id() == get_id())
787 boost::throw_exception(thread_resource_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost thread: trying joining itself"));
788 bool res;
789 if (do_try_join_until_noexcept(timeout, res))
790 {
791 return res;
792 }
793 else
794 {
795 BOOST_THREAD_THROW_ELSE_RETURN(
796 (thread_resource_error(static_cast<int>(system::errc::invalid_argument), "boost thread: thread not joinable")),
797 false
798 );
799 }
800 }
801
802#if !defined(BOOST_NO_IOSTREAM) && defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
803 template<class charT, class traits>
804 BOOST_SYMBOL_VISIBLE
805 std::basic_ostream<charT, traits>&
806 operator<<(std::basic_ostream<charT, traits>& os, const thread::id& x)
807 {
808 return x.print(os);
809 }
810#endif
811
812#if defined BOOST_THREAD_PROVIDES_THREAD_EQ
813 inline bool thread::operator==(const thread& other) const
814 {
815 return get_id()==other.get_id();
816 }
817
818 inline bool thread::operator!=(const thread& other) const
819 {
820 return get_id()!=other.get_id();
821 }
822#endif
823
824 namespace detail
825 {
826 struct thread_exit_function_base
827 {
828 virtual ~thread_exit_function_base()
829 {}
830 virtual void operator()()=0;
831 };
832
833 template<typename F>
834 struct thread_exit_function:
835 thread_exit_function_base
836 {
837 F f;
838
839 thread_exit_function(F f_):
840 f(f_)
841 {}
842
843 void operator()()
844 {
845 f();
846 }
847 };
848
849 void BOOST_THREAD_DECL add_thread_exit_function(thread_exit_function_base*);
850 struct shared_state_base;
851#if defined(BOOST_THREAD_PLATFORM_WIN32)
852 inline void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
853 {
854 detail::thread_data_base* const current_thread_data(detail::get_current_thread_data());
855 if(current_thread_data)
856 {
857 current_thread_data->make_ready_at_thread_exit(as);
858 }
859 }
860#else
861 void BOOST_THREAD_DECL make_ready_at_thread_exit(shared_ptr<shared_state_base> as);
862#endif
863 }
864
865 namespace this_thread
866 {
867 template<typename F>
868 void at_thread_exit(F f)
869 {
870 detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);
871 detail::add_thread_exit_function(thread_exit_func);
872 }
873 }
874}
875
876#ifdef BOOST_MSVC
877#pragma warning(pop)
878#endif
879
880#include <boost/config/abi_suffix.hpp>
881
882#endif
883