OSDN Git Service

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