OSDN Git Service

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