OSDN Git Service

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