release/src-rt-6.x.4708/toolchains/hndtools-arm-linux-2.6.36-uclibc-4.5.3/arm-brcm-linux-uclibcgnueabi/include/c++/4.5.3/future

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