OSDN Git Service

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