OSDN Git Service

22fd36a6fce96ef0e736dbce2af55dca35600460
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / include / std / future
1 // <future> -*- C++ -*-
2
3 // Copyright (C) 2009, 2010, 2011, 2012 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 /** @file include/future
26  *  This is a Standard C++ Library header.
27  */
28
29 #ifndef _GLIBCXX_FUTURE
30 #define _GLIBCXX_FUTURE 1
31
32 #pragma GCC system_header
33
34 #ifndef __GXX_EXPERIMENTAL_CXX0X__
35 # include <bits/c++0x_warning.h>
36 #else
37
38 #include <functional>
39 #include <memory>
40 #include <mutex>
41 #include <thread>
42 #include <condition_variable>
43 #include <system_error>
44 #include <exception>
45 #include <atomic>
46 #include <bits/functexcept.h>
47
48 namespace std _GLIBCXX_VISIBILITY(default)
49 {
50 _GLIBCXX_BEGIN_NAMESPACE_VERSION
51
52   /**
53    * @defgroup futures Futures
54    * @ingroup concurrency
55    *
56    * Classes for futures support.
57    * @{
58    */
59
60   /// Error code for futures
61   enum class future_errc
62   {
63     future_already_retrieved = 1,
64     promise_already_satisfied,
65     no_state,
66     broken_promise
67   };
68
69   /// Specialization.
70   template<>
71     struct is_error_code_enum<future_errc> : public true_type { };
72
73   /// Points to a statically-allocated object derived from error_category.
74   const error_category&
75   future_category() noexcept;
76
77   /// Overload for make_error_code.
78   inline error_code
79   make_error_code(future_errc __errc) noexcept
80   { return error_code(static_cast<int>(__errc), future_category()); }
81
82   /// Overload for make_error_condition.
83   inline error_condition
84   make_error_condition(future_errc __errc) noexcept
85   { return error_condition(static_cast<int>(__errc), future_category()); }
86
87   /**
88    *  @brief Exception type thrown by futures.
89    *  @ingroup exceptions
90    */
91   class future_error : public logic_error
92   {
93     error_code                  _M_code;
94
95   public:
96     explicit future_error(error_code __ec)
97     : logic_error("std::future_error"), _M_code(__ec)
98     { }
99
100     virtual ~future_error() noexcept;
101
102     virtual const char*
103     what() const noexcept;
104
105     const error_code&
106     code() const noexcept { return _M_code; }
107   };
108
109   // Forward declarations.
110   template<typename _Res>
111     class future;
112
113   template<typename _Res>
114     class shared_future;
115
116   template<typename _Res>
117     class atomic_future;
118
119   template<typename _Signature>
120     class packaged_task;
121
122   template<typename _Res>
123     class promise;
124
125   /// Launch code for futures
126   enum class launch
127   {
128     async = 1,
129     deferred = 2
130   };
131
132   constexpr launch operator&(launch __x, launch __y)
133   {
134     return static_cast<launch>(
135         static_cast<int>(__x) & static_cast<int>(__y));
136   }
137
138   constexpr launch operator|(launch __x, launch __y)
139   {
140     return static_cast<launch>(
141         static_cast<int>(__x) | static_cast<int>(__y));
142   }
143
144   constexpr launch operator^(launch __x, launch __y)
145   {
146     return static_cast<launch>(
147         static_cast<int>(__x) ^ static_cast<int>(__y));
148   }
149
150   constexpr launch operator~(launch __x)
151   { return static_cast<launch>(~static_cast<int>(__x)); }
152
153   inline launch& operator&=(launch& __x, launch __y)
154   { return __x = __x & __y; }
155
156   inline launch& operator|=(launch& __x, launch __y)
157   { return __x = __x | __y; }
158
159   inline launch& operator^=(launch& __x, launch __y)
160   { return __x = __x ^ __y; }
161
162   /// Status code for futures
163   enum class future_status
164   {
165     ready,
166     timeout,
167     deferred
168   };
169
170   template<typename _Fn, typename... _Args>
171     future<typename result_of<_Fn(_Args...)>::type>
172     async(launch __policy, _Fn&& __fn, _Args&&... __args);
173
174   template<typename _FnCheck, typename _Fn, typename... _Args>
175     struct __async_sfinae_helper
176     {
177       typedef future<typename result_of<_Fn(_Args...)>::type> type;
178     };
179
180   template<typename _Fn, typename... _Args>
181     struct __async_sfinae_helper<launch, _Fn, _Args...>
182     { };
183
184   template<typename _Fn, typename... _Args>
185     typename
186     __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type
187     async(_Fn&& __fn, _Args&&... __args);
188
189 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \
190   && (ATOMIC_INT_LOCK_FREE > 1)
191
192   /// Base class and enclosing scope.
193   struct __future_base
194   {
195     /// Base class for results.
196     struct _Result_base
197     {
198       exception_ptr             _M_error;
199
200       _Result_base(const _Result_base&) = delete;
201       _Result_base& operator=(const _Result_base&) = delete;
202
203       // _M_destroy() allows derived classes to control deallocation
204       virtual void _M_destroy() = 0;
205
206       struct _Deleter
207       {
208         void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
209       };
210
211     protected:
212       _Result_base();
213       virtual ~_Result_base();
214     };
215
216     /// Result.
217     template<typename _Res>
218       struct _Result : _Result_base
219       {
220       private:
221         typedef alignment_of<_Res>                              __a_of;
222         typedef aligned_storage<sizeof(_Res), __a_of::value>    __align_storage;
223         typedef typename __align_storage::type                  __align_type;
224
225         __align_type            _M_storage;
226         bool                    _M_initialized;
227
228       public:
229         _Result() noexcept : _M_initialized() { }
230         
231         ~_Result()
232         {
233           if (_M_initialized)
234             _M_value().~_Res();
235         }
236
237         // Return lvalue, future will add const or rvalue-reference
238         _Res&
239         _M_value() noexcept { return *static_cast<_Res*>(_M_addr()); }
240
241         void
242         _M_set(const _Res& __res)
243         {
244           ::new (_M_addr()) _Res(__res);
245           _M_initialized = true;
246         }
247
248         void
249         _M_set(_Res&& __res)
250         {
251           ::new (_M_addr()) _Res(std::move(__res));
252           _M_initialized = true;
253         }
254
255       private:
256         void _M_destroy() { delete this; }
257
258         void* _M_addr() noexcept { return static_cast<void*>(&_M_storage); }
259     };
260
261     /// A unique_ptr based on the instantiating type.
262     template<typename _Res>
263       using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>;
264
265     /// Result_alloc.
266     template<typename _Res, typename _Alloc>
267       struct _Result_alloc final : _Result<_Res>, _Alloc
268       {
269         typedef typename allocator_traits<_Alloc>::template
270           rebind_alloc<_Result_alloc> __allocator_type;
271
272         explicit
273         _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
274         { }
275         
276       private:
277         void _M_destroy()
278         {
279           typedef allocator_traits<__allocator_type> __traits;
280           __allocator_type __a(*this);
281           __traits::destroy(__a, this);
282           __traits::deallocate(__a, this, 1);
283         }
284       };
285
286     template<typename _Res, typename _Allocator>
287       static _Ptr<_Result_alloc<_Res, _Allocator>>
288       _S_allocate_result(const _Allocator& __a)
289       {
290         typedef _Result_alloc<_Res, _Allocator> __result_type;
291         typedef allocator_traits<typename __result_type::__allocator_type>
292           __traits;
293         typename __traits::allocator_type __a2(__a);
294         __result_type* __p = __traits::allocate(__a2, 1);
295         __try
296         {
297           __traits::construct(__a2, __p, __a);
298         }
299         __catch(...)
300         {
301           __traits::deallocate(__a2, __p, 1);
302           __throw_exception_again;
303         }
304         return _Ptr<__result_type>(__p);
305       }
306
307
308     /// Base class for state between a promise and one or more
309     /// associated futures.
310     class _State_base
311     {
312       typedef _Ptr<_Result_base> _Ptr_type;
313
314       _Ptr_type                 _M_result;
315       mutex                     _M_mutex;
316       condition_variable        _M_cond;
317       atomic_flag               _M_retrieved;
318       once_flag                 _M_once;
319
320     public:
321       _State_base() noexcept : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { }
322       _State_base(const _State_base&) = delete;
323       _State_base& operator=(const _State_base&) = delete;
324       virtual ~_State_base();
325
326       _Result_base&
327       wait()
328       {
329         _M_run_deferred();
330         unique_lock<mutex> __lock(_M_mutex);
331         _M_cond.wait(__lock, [&] { return _M_ready(); });
332         return *_M_result;
333       }
334
335       template<typename _Rep, typename _Period>
336         future_status
337         wait_for(const chrono::duration<_Rep, _Period>& __rel)
338         {
339           unique_lock<mutex> __lock(_M_mutex);
340           if (_M_cond.wait_for(__lock, __rel, [&] { return _M_ready(); }))
341             return future_status::ready;
342           return future_status::timeout;
343         }
344
345       template<typename _Clock, typename _Duration>
346         future_status
347         wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
348         {
349           unique_lock<mutex> __lock(_M_mutex);
350           if (_M_cond.wait_until(__lock, __abs, [&] { return _M_ready(); }))
351             return future_status::ready;
352           return future_status::timeout;
353         }
354
355       void
356       _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
357       {
358         bool __set = __ignore_failure;
359         // all calls to this function are serialized,
360         // side-effects of invoking __res only happen once
361         call_once(_M_once, &_State_base::_M_do_set, this, ref(__res),
362             ref(__set));
363         if (!__set)
364           __throw_future_error(int(future_errc::promise_already_satisfied));
365       }
366
367       void
368       _M_break_promise(_Ptr_type __res)
369       {
370         if (static_cast<bool>(__res))
371           {
372             error_code __ec(make_error_code(future_errc::broken_promise));
373             __res->_M_error = copy_exception(future_error(__ec));
374             {
375               lock_guard<mutex> __lock(_M_mutex);
376               _M_result.swap(__res);
377             }
378             _M_cond.notify_all();
379           }
380       }
381
382       // Called when this object is passed to a future.
383       void
384       _M_set_retrieved_flag()
385       {
386         if (_M_retrieved.test_and_set())
387           __throw_future_error(int(future_errc::future_already_retrieved));
388       }
389
390       template<typename _Res, typename _Arg>
391         struct _Setter;
392
393       // set lvalues
394       template<typename _Res, typename _Arg>
395         struct _Setter<_Res, _Arg&>
396         {
397           // check this is only used by promise<R>::set_value(const R&)
398           // or promise<R>::set_value(R&)
399           static_assert(is_same<_Res, _Arg&>::value  // promise<R&>
400               || is_same<const _Res, _Arg>::value,  // promise<R>
401               "Invalid specialisation");
402
403           typename promise<_Res>::_Ptr_type operator()()
404           {
405             _State_base::_S_check(_M_promise->_M_future);
406             _M_promise->_M_storage->_M_set(_M_arg);
407             return std::move(_M_promise->_M_storage);
408           }
409           promise<_Res>*    _M_promise;
410           _Arg&             _M_arg;
411         };
412
413       // set rvalues
414       template<typename _Res>
415         struct _Setter<_Res, _Res&&>
416         {
417           typename promise<_Res>::_Ptr_type operator()()
418           {
419             _State_base::_S_check(_M_promise->_M_future);
420             _M_promise->_M_storage->_M_set(std::move(_M_arg));
421             return std::move(_M_promise->_M_storage);
422           }
423           promise<_Res>*    _M_promise;
424           _Res&             _M_arg;
425         };
426
427       struct __exception_ptr_tag { };
428
429       // set exceptions
430       template<typename _Res>
431         struct _Setter<_Res, __exception_ptr_tag>
432         {
433           typename promise<_Res>::_Ptr_type operator()()
434           {
435             _State_base::_S_check(_M_promise->_M_future);
436             _M_promise->_M_storage->_M_error = _M_ex;
437             return std::move(_M_promise->_M_storage);
438           }
439
440           promise<_Res>*   _M_promise;
441           exception_ptr&    _M_ex;
442         };
443
444       template<typename _Res, typename _Arg>
445         static _Setter<_Res, _Arg&&>
446         __setter(promise<_Res>* __prom, _Arg&& __arg)
447         {
448           return _Setter<_Res, _Arg&&>{ __prom, __arg };
449         }
450
451       template<typename _Res>
452         static _Setter<_Res, __exception_ptr_tag>
453         __setter(exception_ptr& __ex, promise<_Res>* __prom)
454         {
455           return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex };
456         }
457
458       static _Setter<void, void>
459       __setter(promise<void>* __prom);
460
461       template<typename _Tp>
462         static bool
463         _S_check(const shared_ptr<_Tp>& __p)
464         {
465           if (!static_cast<bool>(__p))
466             __throw_future_error((int)future_errc::no_state);
467         }
468
469     private:
470       void
471       _M_do_set(function<_Ptr_type()>& __f, bool& __set)
472       {
473         _Ptr_type __res = __f();
474         {
475           lock_guard<mutex> __lock(_M_mutex);
476           _M_result.swap(__res);
477         }
478         _M_cond.notify_all();
479         __set = true;
480       }
481
482       bool _M_ready() const noexcept { return static_cast<bool>(_M_result); }
483
484       // Misnamed: waits for completion of async function.
485       virtual void _M_run_deferred() { }
486     };
487
488     template<typename _BoundFn, typename = typename _BoundFn::result_type>
489       class _Deferred_state;
490
491     class _Async_state_common;
492
493     template<typename _BoundFn, typename = typename _BoundFn::result_type>
494       class _Async_state_impl;
495
496     template<typename _Signature>
497       class _Task_state;
498
499     template<typename _BoundFn>
500       static std::shared_ptr<_State_base>
501       _S_make_deferred_state(_BoundFn&& __fn);
502
503     template<typename _BoundFn>
504       static std::shared_ptr<_State_base>
505       _S_make_async_state(_BoundFn&& __fn);
506
507     template<typename _Res_ptr, typename _Res>
508       struct _Task_setter;
509
510     template<typename _Res_ptr, typename _BoundFn>
511       class _Task_setter_helper
512       {
513         typedef typename remove_reference<_BoundFn>::type::result_type __res;
514       public:
515         typedef _Task_setter<_Res_ptr, __res> __type;
516       };
517
518     template<typename _Res_ptr, typename _BoundFn>
519       static typename _Task_setter_helper<_Res_ptr, _BoundFn>::__type
520       _S_task_setter(_Res_ptr& __ptr, _BoundFn&& __call)
521       {
522         typedef _Task_setter_helper<_Res_ptr, _BoundFn> __helper_type;
523         typedef typename __helper_type::__type _Setter;
524         return _Setter{ __ptr, std::ref(__call) };
525       }
526   };
527
528   /// Partial specialization for reference types.
529   template<typename _Res>
530     struct __future_base::_Result<_Res&> : __future_base::_Result_base
531     {
532       _Result() noexcept : _M_value_ptr() { }
533
534       void _M_set(_Res& __res) noexcept { _M_value_ptr = &__res; }
535
536       _Res& _M_get() noexcept { return *_M_value_ptr; }
537
538     private:
539       _Res*                     _M_value_ptr;
540
541       void _M_destroy() { delete this; }
542     };
543
544   /// Explicit specialization for void.
545   template<>
546     struct __future_base::_Result<void> : __future_base::_Result_base
547     {
548     private:
549       void _M_destroy() { delete this; }
550     };
551
552
553   /// Common implementation for future and shared_future.
554   template<typename _Res>
555     class __basic_future : public __future_base
556     {
557     protected:
558       typedef shared_ptr<_State_base>           __state_type;
559       typedef __future_base::_Result<_Res>&     __result_type;
560
561     private:
562       __state_type              _M_state;
563
564     public:
565       // Disable copying.
566       __basic_future(const __basic_future&) = delete;
567       __basic_future& operator=(const __basic_future&) = delete;
568
569       bool
570       valid() const noexcept { return static_cast<bool>(_M_state); }
571
572       void
573       wait() const
574       {
575         _State_base::_S_check(_M_state);
576         _M_state->wait();
577       }
578
579       template<typename _Rep, typename _Period>
580         future_status
581         wait_for(const chrono::duration<_Rep, _Period>& __rel) const
582         {
583           _State_base::_S_check(_M_state);
584           return _M_state->wait_for(__rel);
585         }
586
587       template<typename _Clock, typename _Duration>
588         future_status
589         wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
590         {
591           _State_base::_S_check(_M_state);
592           return _M_state->wait_until(__abs);
593         }
594
595     protected:
596       /// Wait for the state to be ready and rethrow any stored exception
597       __result_type
598       _M_get_result()
599       {
600         _State_base::_S_check(_M_state);
601         _Result_base& __res = _M_state->wait();
602         if (!(__res._M_error == 0))
603           rethrow_exception(__res._M_error);
604         return static_cast<__result_type>(__res);
605       }
606
607       void _M_swap(__basic_future& __that) noexcept
608       {
609         _M_state.swap(__that._M_state);
610       }
611
612       // Construction of a future by promise::get_future()
613       explicit
614       __basic_future(const __state_type& __state) : _M_state(__state)
615       {
616         _State_base::_S_check(_M_state);
617         _M_state->_M_set_retrieved_flag();
618       }
619
620       // Copy construction from a shared_future
621       explicit
622       __basic_future(const shared_future<_Res>&) noexcept;
623
624       // Move construction from a shared_future
625       explicit
626       __basic_future(shared_future<_Res>&&) noexcept;
627
628       // Move construction from a future
629       explicit
630       __basic_future(future<_Res>&&) noexcept;
631
632       constexpr __basic_future() noexcept : _M_state() { }
633
634       struct _Reset
635       {
636         explicit _Reset(__basic_future& __fut) noexcept : _M_fut(__fut) { }
637         ~_Reset() { _M_fut._M_state.reset(); }
638         __basic_future& _M_fut;
639       };
640     };
641
642
643   /// Primary template for future.
644   template<typename _Res>
645     class future : public __basic_future<_Res>
646     {
647       friend class promise<_Res>;
648       template<typename> friend class packaged_task;
649       template<typename _Fn, typename... _Args>
650         friend future<typename result_of<_Fn(_Args...)>::type>
651         async(launch, _Fn&&, _Args&&...);
652
653       typedef __basic_future<_Res> _Base_type;
654       typedef typename _Base_type::__state_type __state_type;
655
656       explicit
657       future(const __state_type& __state) : _Base_type(__state) { }
658
659     public:
660       constexpr future() noexcept : _Base_type() { }
661
662       /// Move constructor
663       future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
664
665       // Disable copying
666       future(const future&) = delete;
667       future& operator=(const future&) = delete;
668
669       future& operator=(future&& __fut) noexcept
670       {
671         future(std::move(__fut))._M_swap(*this);
672         return *this;
673       }
674
675       /// Retrieving the value
676       _Res
677       get()
678       {
679         typename _Base_type::_Reset __reset(*this);
680         return std::move(this->_M_get_result()._M_value());
681       }
682
683       shared_future<_Res> share();
684     };
685
686   /// Partial specialization for future<R&>
687   template<typename _Res>
688     class future<_Res&> : public __basic_future<_Res&>
689     {
690       friend class promise<_Res&>;
691       template<typename> friend class packaged_task;
692       template<typename _Fn, typename... _Args>
693         friend future<typename result_of<_Fn(_Args...)>::type>
694         async(launch, _Fn&&, _Args&&...);
695
696       typedef __basic_future<_Res&> _Base_type;
697       typedef typename _Base_type::__state_type __state_type;
698
699       explicit
700       future(const __state_type& __state) : _Base_type(__state) { }
701
702     public:
703       constexpr future() noexcept : _Base_type() { }
704
705       /// Move constructor
706       future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
707
708       // Disable copying
709       future(const future&) = delete;
710       future& operator=(const future&) = delete;
711
712       future& operator=(future&& __fut) noexcept
713       {
714         future(std::move(__fut))._M_swap(*this);
715         return *this;
716       }
717
718       /// Retrieving the value
719       _Res&
720       get()
721       {
722         typename _Base_type::_Reset __reset(*this);
723         return this->_M_get_result()._M_get();
724       }
725
726       shared_future<_Res&> share();
727     };
728
729   /// Explicit specialization for future<void>
730   template<>
731     class future<void> : public __basic_future<void>
732     {
733       friend class promise<void>;
734       template<typename> friend class packaged_task;
735       template<typename _Fn, typename... _Args>
736         friend future<typename result_of<_Fn(_Args...)>::type>
737         async(launch, _Fn&&, _Args&&...);
738
739       typedef __basic_future<void> _Base_type;
740       typedef typename _Base_type::__state_type __state_type;
741
742       explicit
743       future(const __state_type& __state) : _Base_type(__state) { }
744
745     public:
746       constexpr future() noexcept : _Base_type() { }
747
748       /// Move constructor
749       future(future&& __uf) noexcept : _Base_type(std::move(__uf)) { }
750
751       // Disable copying
752       future(const future&) = delete;
753       future& operator=(const future&) = delete;
754
755       future& operator=(future&& __fut) noexcept
756       {
757         future(std::move(__fut))._M_swap(*this);
758         return *this;
759       }
760
761       /// Retrieving the value
762       void
763       get()
764       {
765         typename _Base_type::_Reset __reset(*this);
766         this->_M_get_result();
767       }
768
769       shared_future<void> share();
770     };
771
772
773   /// Primary template for shared_future.
774   template<typename _Res>
775     class shared_future : public __basic_future<_Res>
776     {
777       typedef __basic_future<_Res> _Base_type;
778
779     public:
780       constexpr shared_future() noexcept : _Base_type() { }
781
782       /// Copy constructor
783       shared_future(const shared_future& __sf) : _Base_type(__sf) { }
784
785       /// Construct from a future rvalue
786       shared_future(future<_Res>&& __uf) noexcept
787       : _Base_type(std::move(__uf))
788       { }
789
790       /// Construct from a shared_future rvalue
791       shared_future(shared_future&& __sf) noexcept
792       : _Base_type(std::move(__sf))
793       { }
794
795       shared_future& operator=(const shared_future& __sf)
796       {
797         shared_future(__sf)._M_swap(*this);
798         return *this;
799       }
800
801       shared_future& operator=(shared_future&& __sf) noexcept
802       {
803         shared_future(std::move(__sf))._M_swap(*this);
804         return *this;
805       }
806
807       /// Retrieving the value
808       const _Res&
809       get()
810       {
811         typename _Base_type::__result_type __r = this->_M_get_result();
812         _Res& __rs(__r._M_value());
813         return __rs;
814       }
815     };
816
817   /// Partial specialization for shared_future<R&>
818   template<typename _Res>
819     class shared_future<_Res&> : public __basic_future<_Res&>
820     {
821       typedef __basic_future<_Res&>           _Base_type;
822
823     public:
824       constexpr shared_future() noexcept : _Base_type() { }
825
826       /// Copy constructor
827       shared_future(const shared_future& __sf) : _Base_type(__sf) { }
828
829       /// Construct from a future rvalue
830       shared_future(future<_Res&>&& __uf) noexcept
831       : _Base_type(std::move(__uf))
832       { }
833
834       /// Construct from a shared_future rvalue
835       shared_future(shared_future&& __sf) noexcept
836       : _Base_type(std::move(__sf))
837       { }
838
839       shared_future& operator=(const shared_future& __sf)
840       {
841         shared_future(__sf)._M_swap(*this);
842         return *this;
843       }
844
845       shared_future& operator=(shared_future&& __sf) noexcept
846       {
847         shared_future(std::move(__sf))._M_swap(*this);
848         return *this;
849       }
850
851       /// Retrieving the value
852       _Res&
853       get() { return this->_M_get_result()._M_get(); }
854     };
855
856   /// Explicit specialization for shared_future<void>
857   template<>
858     class shared_future<void> : public __basic_future<void>
859     {
860       typedef __basic_future<void> _Base_type;
861
862     public:
863       constexpr shared_future() noexcept : _Base_type() { }
864
865       /// Copy constructor
866       shared_future(const shared_future& __sf) : _Base_type(__sf) { }
867
868       /// Construct from a future rvalue
869       shared_future(future<void>&& __uf) noexcept
870       : _Base_type(std::move(__uf))
871       { }
872
873       /// Construct from a shared_future rvalue
874       shared_future(shared_future&& __sf) noexcept
875       : _Base_type(std::move(__sf))
876       { }
877
878       shared_future& operator=(const shared_future& __sf)
879       {
880         shared_future(__sf)._M_swap(*this);
881         return *this;
882       }
883
884       shared_future& operator=(shared_future&& __sf) noexcept
885       {
886         shared_future(std::move(__sf))._M_swap(*this);
887         return *this;
888       }
889
890       // Retrieving the value
891       void
892       get() { this->_M_get_result(); }
893     };
894
895   // Now we can define the protected __basic_future constructors.
896   template<typename _Res>
897     inline __basic_future<_Res>::
898     __basic_future(const shared_future<_Res>& __sf) noexcept
899     : _M_state(__sf._M_state)
900     { }
901
902   template<typename _Res>
903     inline __basic_future<_Res>::
904     __basic_future(shared_future<_Res>&& __sf) noexcept
905     : _M_state(std::move(__sf._M_state))
906     { }
907
908   template<typename _Res>
909     inline __basic_future<_Res>::
910     __basic_future(future<_Res>&& __uf) noexcept
911     : _M_state(std::move(__uf._M_state))
912     { }
913
914   template<typename _Res>
915     inline shared_future<_Res>
916     future<_Res>::share()
917     { return shared_future<_Res>(std::move(*this)); }
918
919   template<typename _Res>
920     inline shared_future<_Res&>
921     future<_Res&>::share()
922     { return shared_future<_Res&>(std::move(*this)); }
923
924   inline shared_future<void>
925   future<void>::share()
926   { return shared_future<void>(std::move(*this)); }
927
928   /// Primary template for promise
929   template<typename _Res>
930     class promise
931     {
932       typedef __future_base::_State_base        _State;
933       typedef __future_base::_Result<_Res>      _Res_type;
934       typedef __future_base::_Ptr<_Res_type>    _Ptr_type;
935       template<typename, typename> friend class _State::_Setter;
936
937       shared_ptr<_State>                        _M_future;
938       _Ptr_type                                 _M_storage;
939
940     public:
941       promise()
942       : _M_future(std::make_shared<_State>()),
943         _M_storage(new _Res_type())
944       { }
945
946       promise(promise&& __rhs) noexcept
947       : _M_future(std::move(__rhs._M_future)),
948         _M_storage(std::move(__rhs._M_storage))
949       { }
950
951       template<typename _Allocator>
952         promise(allocator_arg_t, const _Allocator& __a)
953         : _M_future(std::allocate_shared<_State>(__a)),
954           _M_storage(__future_base::_S_allocate_result<_Res>(__a))
955         { }
956
957       template<typename _Allocator>
958         promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
959         : _M_future(std::move(__rhs._M_future)),
960           _M_storage(std::move(__rhs._M_storage))
961         { }
962
963       promise(const promise&) = delete;
964
965       ~promise()
966       {
967         if (static_cast<bool>(_M_future) && !_M_future.unique())
968           _M_future->_M_break_promise(std::move(_M_storage));
969       }
970
971       // Assignment
972       promise&
973       operator=(promise&& __rhs) noexcept
974       {
975         promise(std::move(__rhs)).swap(*this);
976         return *this;
977       }
978
979       promise& operator=(const promise&) = delete;
980
981       void
982       swap(promise& __rhs) noexcept
983       {
984         _M_future.swap(__rhs._M_future);
985         _M_storage.swap(__rhs._M_storage);
986       }
987
988       // Retrieving the result
989       future<_Res>
990       get_future()
991       { return future<_Res>(_M_future); }
992
993       // Setting the result
994       void
995       set_value(const _Res& __r)
996       {
997         auto __setter = _State::__setter(this, __r);
998         _M_future->_M_set_result(std::move(__setter));
999       }
1000
1001       void
1002       set_value(_Res&& __r)
1003       {
1004         auto __setter = _State::__setter(this, std::move(__r));
1005         _M_future->_M_set_result(std::move(__setter));
1006       }
1007
1008       void
1009       set_exception(exception_ptr __p)
1010       {
1011         auto __setter = _State::__setter(__p, this);
1012         _M_future->_M_set_result(std::move(__setter));
1013       }
1014     };
1015
1016   template<typename _Res>
1017     inline void
1018     swap(promise<_Res>& __x, promise<_Res>& __y) noexcept
1019     { __x.swap(__y); }
1020
1021   template<typename _Res, typename _Alloc>
1022     struct uses_allocator<promise<_Res>, _Alloc>
1023     : public true_type { };
1024
1025
1026   /// Partial specialization for promise<R&>
1027   template<typename _Res>
1028     class promise<_Res&>
1029     {
1030       typedef __future_base::_State_base        _State;
1031       typedef __future_base::_Result<_Res&>     _Res_type;
1032       typedef __future_base::_Ptr<_Res_type>    _Ptr_type;
1033       template<typename, typename> friend class _State::_Setter;
1034
1035       shared_ptr<_State>                        _M_future;
1036       _Ptr_type                                 _M_storage;
1037
1038     public:
1039       promise()
1040       : _M_future(std::make_shared<_State>()),
1041         _M_storage(new _Res_type())
1042       { }
1043
1044       promise(promise&& __rhs) noexcept
1045       : _M_future(std::move(__rhs._M_future)),
1046         _M_storage(std::move(__rhs._M_storage))
1047       { }
1048
1049       template<typename _Allocator>
1050         promise(allocator_arg_t, const _Allocator& __a)
1051         : _M_future(std::allocate_shared<_State>(__a)),
1052           _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
1053         { }
1054
1055       template<typename _Allocator>
1056         promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
1057         : _M_future(std::move(__rhs._M_future)),
1058           _M_storage(std::move(__rhs._M_storage))
1059         { }
1060
1061       promise(const promise&) = delete;
1062
1063       ~promise()
1064       {
1065         if (static_cast<bool>(_M_future) && !_M_future.unique())
1066           _M_future->_M_break_promise(std::move(_M_storage));
1067       }
1068
1069       // Assignment
1070       promise&
1071       operator=(promise&& __rhs) noexcept
1072       {
1073         promise(std::move(__rhs)).swap(*this);
1074         return *this;
1075       }
1076
1077       promise& operator=(const promise&) = delete;
1078
1079       void
1080       swap(promise& __rhs) noexcept
1081       {
1082         _M_future.swap(__rhs._M_future);
1083         _M_storage.swap(__rhs._M_storage);
1084       }
1085
1086       // Retrieving the result
1087       future<_Res&>
1088       get_future()
1089       { return future<_Res&>(_M_future); }
1090
1091       // Setting the result
1092       void
1093       set_value(_Res& __r)
1094       {
1095         auto __setter = _State::__setter(this, __r);
1096         _M_future->_M_set_result(std::move(__setter));
1097       }
1098
1099       void
1100       set_exception(exception_ptr __p)
1101       {
1102         auto __setter = _State::__setter(__p, this);
1103         _M_future->_M_set_result(std::move(__setter));
1104       }
1105     };
1106
1107   /// Explicit specialization for promise<void>
1108   template<>
1109     class promise<void>
1110     {
1111       typedef __future_base::_State_base        _State;
1112       typedef __future_base::_Result<void>      _Res_type;
1113       typedef __future_base::_Ptr<_Res_type>    _Ptr_type;
1114       template<typename, typename> friend class _State::_Setter;
1115
1116       shared_ptr<_State>                        _M_future;
1117       _Ptr_type                                 _M_storage;
1118
1119     public:
1120       promise()
1121       : _M_future(std::make_shared<_State>()),
1122         _M_storage(new _Res_type())
1123       { }
1124
1125       promise(promise&& __rhs) noexcept
1126       : _M_future(std::move(__rhs._M_future)),
1127         _M_storage(std::move(__rhs._M_storage))
1128       { }
1129
1130       template<typename _Allocator>
1131         promise(allocator_arg_t, const _Allocator& __a)
1132         : _M_future(std::allocate_shared<_State>(__a)),
1133           _M_storage(__future_base::_S_allocate_result<void>(__a))
1134         { }
1135
1136       template<typename _Allocator>
1137         promise(allocator_arg_t, const _Allocator&, promise&& __rhs)
1138         : _M_future(std::move(__rhs._M_future)),
1139           _M_storage(std::move(__rhs._M_storage))
1140         { }
1141
1142       promise(const promise&) = delete;
1143
1144       ~promise()
1145       {
1146         if (static_cast<bool>(_M_future) && !_M_future.unique())
1147           _M_future->_M_break_promise(std::move(_M_storage));
1148       }
1149
1150       // Assignment
1151       promise&
1152       operator=(promise&& __rhs) noexcept
1153       {
1154         promise(std::move(__rhs)).swap(*this);
1155         return *this;
1156       }
1157
1158       promise& operator=(const promise&) = delete;
1159
1160       void
1161       swap(promise& __rhs) noexcept
1162       {
1163         _M_future.swap(__rhs._M_future);
1164         _M_storage.swap(__rhs._M_storage);
1165       }
1166
1167       // Retrieving the result
1168       future<void>
1169       get_future()
1170       { return future<void>(_M_future); }
1171
1172       // Setting the result
1173       void set_value();
1174
1175       void
1176       set_exception(exception_ptr __p)
1177       {
1178         auto __setter = _State::__setter(__p, this);
1179         _M_future->_M_set_result(std::move(__setter));
1180       }
1181     };
1182
1183   // set void
1184   template<>
1185     struct __future_base::_State_base::_Setter<void, void>
1186     {
1187       promise<void>::_Ptr_type operator()()
1188       {
1189         _State_base::_S_check(_M_promise->_M_future);
1190         return std::move(_M_promise->_M_storage);
1191       }
1192
1193       promise<void>*    _M_promise;
1194     };
1195
1196   inline __future_base::_State_base::_Setter<void, void>
1197   __future_base::_State_base::__setter(promise<void>* __prom)
1198   {
1199     return _Setter<void, void>{ __prom };
1200   }
1201
1202   inline void
1203   promise<void>::set_value()
1204   {
1205     auto __setter = _State::__setter(this);
1206     _M_future->_M_set_result(std::move(__setter));
1207   }
1208
1209
1210   template<typename _Ptr_type, typename _Res>
1211     struct __future_base::_Task_setter
1212     {
1213       _Ptr_type operator()()
1214       {
1215         __try
1216           {
1217             _M_result->_M_set(_M_fn());
1218           }
1219         __catch(...)
1220           {
1221             _M_result->_M_error = current_exception();
1222           }
1223         return std::move(_M_result);
1224       }
1225       _Ptr_type&                _M_result;
1226       std::function<_Res()>     _M_fn;
1227     };
1228
1229   template<typename _Ptr_type>
1230     struct __future_base::_Task_setter<_Ptr_type, void>
1231     {
1232       _Ptr_type operator()()
1233       {
1234         __try
1235           {
1236             _M_fn();
1237           }
1238         __catch(...)
1239           {
1240             _M_result->_M_error = current_exception();
1241           }
1242         return std::move(_M_result);
1243       }
1244       _Ptr_type&                _M_result;
1245       std::function<void()>     _M_fn;
1246     };
1247
1248   template<typename _Res, typename... _Args>
1249     struct __future_base::_Task_state<_Res(_Args...)> final
1250     : __future_base::_State_base
1251     {
1252       typedef _Res _Res_type;
1253
1254       _Task_state(std::function<_Res(_Args...)> __task)
1255       : _M_result(new _Result<_Res>()), _M_task(std::move(__task))
1256       { }
1257
1258       template<typename _Func, typename _Alloc>
1259         _Task_state(_Func&& __task, const _Alloc& __a)
1260         : _M_result(_S_allocate_result<_Res>(__a)),
1261           _M_task(allocator_arg, __a, std::move(__task))
1262         { }
1263
1264       void
1265       _M_run(_Args... __args)
1266       {
1267         // bound arguments decay so wrap lvalue references
1268         auto __boundfn = std::__bind_simple(std::ref(_M_task),
1269             _S_maybe_wrap_ref(std::forward<_Args>(__args))...);
1270         auto __setter = _S_task_setter(_M_result, std::move(__boundfn));
1271         _M_set_result(std::move(__setter));
1272       }
1273
1274       typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
1275       _Ptr_type _M_result;
1276       std::function<_Res(_Args...)> _M_task;
1277
1278       template<typename _Tp>
1279         static reference_wrapper<_Tp>
1280         _S_maybe_wrap_ref(_Tp& __t)
1281         { return std::ref(__t); }
1282
1283       template<typename _Tp>
1284         static typename enable_if<!is_lvalue_reference<_Tp>::value,
1285                         _Tp>::type&&
1286         _S_maybe_wrap_ref(_Tp&& __t)
1287         { return std::forward<_Tp>(__t); }
1288     };
1289
1290   template<typename _Task, typename _Fn, bool
1291            = is_same<_Task, typename decay<_Fn>::type>::value>
1292     struct __constrain_pkgdtask
1293     { typedef void __type; };
1294
1295   template<typename _Task, typename _Fn>
1296     struct __constrain_pkgdtask<_Task, _Fn, true>
1297     { };
1298
1299   /// packaged_task
1300   template<typename _Res, typename... _ArgTypes>
1301     class packaged_task<_Res(_ArgTypes...)>
1302     {
1303       typedef __future_base::_Task_state<_Res(_ArgTypes...)>  _State_type;
1304       shared_ptr<_State_type>                   _M_state;
1305
1306     public:
1307       // Construction and destruction
1308       packaged_task() noexcept { }
1309
1310       template<typename _Allocator>
1311         explicit
1312         packaged_task(allocator_arg_t, const _Allocator& __a) noexcept
1313         { }
1314
1315       template<typename _Fn, typename = typename
1316                __constrain_pkgdtask<packaged_task, _Fn>::__type>
1317         explicit
1318         packaged_task(_Fn&& __fn)
1319         : _M_state(std::make_shared<_State_type>(std::forward<_Fn>(__fn)))
1320         { }
1321
1322       template<typename _Fn, typename _Allocator, typename = typename
1323                __constrain_pkgdtask<packaged_task, _Fn>::__type>
1324         explicit
1325         packaged_task(allocator_arg_t, const _Allocator& __a, _Fn&& __fn)
1326         : _M_state(std::allocate_shared<_State_type>(__a,
1327                                                      std::forward<_Fn>(__fn)))
1328         { }
1329
1330       ~packaged_task()
1331       {
1332         if (static_cast<bool>(_M_state) && !_M_state.unique())
1333           _M_state->_M_break_promise(std::move(_M_state->_M_result));
1334       }
1335
1336       // No copy
1337       packaged_task(const packaged_task&) = delete;
1338       packaged_task& operator=(const packaged_task&) = delete;
1339
1340       template<typename _Allocator>
1341         explicit
1342         packaged_task(allocator_arg_t, const _Allocator&,
1343                       const packaged_task&) = delete;
1344
1345       // Move support
1346       packaged_task(packaged_task&& __other) noexcept
1347       { this->swap(__other); }
1348
1349       template<typename _Allocator>
1350         explicit
1351         packaged_task(allocator_arg_t, const _Allocator&,
1352                       packaged_task&& __other) noexcept
1353         { this->swap(__other); }
1354
1355       packaged_task& operator=(packaged_task&& __other) noexcept
1356       {
1357         packaged_task(std::move(__other)).swap(*this);
1358         return *this;
1359       }
1360
1361       void
1362       swap(packaged_task& __other) noexcept
1363       { _M_state.swap(__other._M_state); }
1364
1365       bool
1366       valid() const noexcept
1367       { return static_cast<bool>(_M_state); }
1368
1369       // Result retrieval
1370       future<_Res>
1371       get_future()
1372       { return future<_Res>(_M_state); }
1373
1374       // Execution
1375       void
1376       operator()(_ArgTypes... __args)
1377       {
1378         __future_base::_State_base::_S_check(_M_state);
1379         _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
1380       }
1381
1382       void
1383       reset()
1384       {
1385         __future_base::_State_base::_S_check(_M_state);
1386         packaged_task(std::move(_M_state->_M_task)).swap(*this);
1387       }
1388     };
1389
1390   /// swap
1391   template<typename _Res, typename... _ArgTypes>
1392     inline void
1393     swap(packaged_task<_Res(_ArgTypes...)>& __x,
1394          packaged_task<_Res(_ArgTypes...)>& __y) noexcept
1395     { __x.swap(__y); }
1396
1397   template<typename _Res, typename _Alloc>
1398     struct uses_allocator<packaged_task<_Res>, _Alloc>
1399     : public true_type { };
1400
1401
1402   template<typename _BoundFn, typename _Res>
1403     class __future_base::_Deferred_state final
1404     : public __future_base::_State_base
1405     {
1406     public:
1407       explicit
1408       _Deferred_state(_BoundFn&& __fn)
1409       : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
1410       { }
1411
1412     private:
1413       typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
1414       _Ptr_type _M_result;
1415       _BoundFn _M_fn;
1416
1417       virtual void
1418       _M_run_deferred()
1419       {
1420         // safe to call multiple times so ignore failure
1421         _M_set_result(_S_task_setter(_M_result, _M_fn), true);
1422       }
1423     };
1424
1425   class __future_base::_Async_state_common : public __future_base::_State_base
1426   {
1427   protected:
1428 #ifdef _GLIBCXX_ASYNC_ABI_COMPAT
1429     ~_Async_state_common();
1430 #else
1431     ~_Async_state_common() = default;
1432 #endif
1433
1434     // Allow non-timed waiting functions to block until the thread completes,
1435     // as if joined.
1436     virtual void _M_run_deferred() { _M_join(); }
1437
1438     void _M_join() { std::call_once(_M_once, &thread::join, ref(_M_thread)); }
1439
1440     thread _M_thread;
1441     once_flag _M_once;
1442   };
1443
1444   template<typename _BoundFn, typename _Res>
1445     class __future_base::_Async_state_impl final
1446     : public __future_base::_Async_state_common
1447     {
1448     public:
1449       explicit
1450       _Async_state_impl(_BoundFn&& __fn)
1451       : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
1452       {
1453         _M_thread = std::thread{ [this] {
1454           _M_set_result(_S_task_setter(_M_result, _M_fn));
1455         } };
1456       }
1457
1458       ~_Async_state_impl() { _M_join(); }
1459
1460     private:
1461       typedef __future_base::_Ptr<_Result<_Res>> _Ptr_type;
1462       _Ptr_type _M_result;
1463       _BoundFn _M_fn;
1464     };
1465
1466   template<typename _BoundFn>
1467     inline std::shared_ptr<__future_base::_State_base>
1468     __future_base::_S_make_deferred_state(_BoundFn&& __fn)
1469     {
1470       typedef typename remove_reference<_BoundFn>::type __fn_type;
1471       typedef _Deferred_state<__fn_type> __state_type;
1472       return std::make_shared<__state_type>(std::move(__fn));
1473     }
1474
1475   template<typename _BoundFn>
1476     inline std::shared_ptr<__future_base::_State_base>
1477     __future_base::_S_make_async_state(_BoundFn&& __fn)
1478     {
1479       typedef typename remove_reference<_BoundFn>::type __fn_type;
1480       typedef _Async_state_impl<__fn_type> __state_type;
1481       return std::make_shared<__state_type>(std::move(__fn));
1482     }
1483
1484
1485   /// async
1486   template<typename _Fn, typename... _Args>
1487     future<typename result_of<_Fn(_Args...)>::type>
1488     async(launch __policy, _Fn&& __fn, _Args&&... __args)
1489     {
1490       typedef typename result_of<_Fn(_Args...)>::type result_type;
1491       std::shared_ptr<__future_base::_State_base> __state;
1492       if ((__policy & (launch::async|launch::deferred)) == launch::async)
1493         {
1494           __state = __future_base::_S_make_async_state(std::__bind_simple(
1495               std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
1496         }
1497       else
1498         {
1499           __state = __future_base::_S_make_deferred_state(std::__bind_simple(
1500               std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
1501         }
1502       return future<result_type>(__state);
1503     }
1504
1505   /// async, potential overload
1506   template<typename _Fn, typename... _Args>
1507     inline typename
1508     __async_sfinae_helper<typename decay<_Fn>::type, _Fn, _Args...>::type
1509     async(_Fn&& __fn, _Args&&... __args)
1510     {
1511       return async(launch::async|launch::deferred, std::forward<_Fn>(__fn),
1512                    std::forward<_Args>(__args)...);
1513     }
1514
1515 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
1516        // && ATOMIC_INT_LOCK_FREE
1517
1518   // @} group futures
1519 _GLIBCXX_END_NAMESPACE_VERSION
1520 } // namespace
1521
1522 #endif // __GXX_EXPERIMENTAL_CXX0X__
1523
1524 #endif // _GLIBCXX_FUTURE