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