contrib/gcc-4.7/libstdc++-v3/include/std/future

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