include/future

// -*- C++ -*-
//===--------------------------- future -----------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_FUTURE
#define _LIBCPP_FUTURE

/*
 future synopsis

namespace std
{

enum class future_errc
{
 broken_promise,
 future_already_retrieved,
 promise_already_satisfied,
 no_state
};

enum class launch
{
 any,
 async,
 sync
};

enum class future_status
{
 ready,
 timeout,
 deferred
};

template <> struct is_error_code_enum<future_errc> : public true_type { };
error_code make_error_code(future_errc e);
error_condition make_error_condition(future_errc e);

const error_category& future_category();

class future_error
 : public logic_error
{
public:
 future_error(error_code ec); // exposition only

 const error_code& code() const throw();
 const char* what() const throw();
};

template <class R>
class promise
{
public:
 promise();
 template <class Allocator>
 promise(allocator_arg_t, const Allocator& a);
 promise(promise&& rhs);
 promise(const promise& rhs) = delete;
 ~promise();

 // assignment
 promise& operator=(promise&& rhs);
 promise& operator=(const promise& rhs) = delete;
 void swap(promise& other);

 // retrieving the result
 future<R> get_future();

 // setting the result
 void set_value(const R& r);
 void set_value(R&& r);
 void set_exception(exception_ptr p);

 // setting the result with deferred notification
 void set_value_at_thread_exit(const R& r);
 void set_value_at_thread_exit(R&& r);
 void set_exception_at_thread_exit(exception_ptr p);
};

template <class R>
class promise<R&>
{
public:
 promise();
 template <class Allocator>
 promise(allocator_arg_t, const Allocator& a);
 promise(promise&& rhs);
 promise(const promise& rhs) = delete;
 ~promise();

 // assignment
 promise& operator=(promise&& rhs);
 promise& operator=(const promise& rhs) = delete;
 void swap(promise& other);

 // retrieving the result
 future<R&> get_future();

 // setting the result
 void set_value(R& r);
 void set_exception(exception_ptr p);

 // setting the result with deferred notification
 void set_value_at_thread_exit(R&);
 void set_exception_at_thread_exit(exception_ptr p);
};

template <>
class promise<void>
{
public:
 promise();
 template <class Allocator>
 promise(allocator_arg_t, const Allocator& a);
 promise(promise&& rhs);
 promise(const promise& rhs) = delete;
 ~promise();

 // assignment
 promise& operator=(promise&& rhs);
 promise& operator=(const promise& rhs) = delete;
 void swap(promise& other);

 // retrieving the result
 future<void> get_future();

 // setting the result
 void set_value();
 void set_exception(exception_ptr p);

 // setting the result with deferred notification
 void set_value_at_thread_exit();
 void set_exception_at_thread_exit(exception_ptr p);
};

template <class R> void swap(promise<R>& x, promise<R>& y);

template <class R, class Alloc>
 struct uses_allocator<promise<R>, Alloc> : public true_type {};

template <class R>
class future
{
public:
 future();
 future(future&&);
 future(const future& rhs) = delete;
 ~future();
 future& operator=(const future& rhs) = delete;
 future& operator=(future&&);

 // retrieving the value
 R get();

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <class R>
class future<R&>
{
public:
 future();
 future(future&&);
 future(const future& rhs) = delete;
 ~future();
 future& operator=(const future& rhs) = delete;
 future& operator=(future&&);

 // retrieving the value
 R& get();

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <>
class future<void>
{
public:
 future();
 future(future&&);
 future(const future& rhs) = delete;
 ~future();
 future& operator=(const future& rhs) = delete;
 future& operator=(future&&);

 // retrieving the value
 void get();

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <class R>
class shared_future
{
public:
 shared_future();
 shared_future(const shared_future& rhs);
 shared_future(future<R>&&);
 shared_future(shared_future&& rhs);
 ~shared_future();
 shared_future& operator=(const shared_future& rhs);
 shared_future& operator=(shared_future&& rhs);

 // retrieving the value
 const R& get() const;

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <class R>
class shared_future<R&>
{
public:
 shared_future();
 shared_future(const shared_future& rhs);
 shared_future(future<R&>&&);
 shared_future(shared_future&& rhs);
 ~shared_future();
 shared_future& operator=(const shared_future& rhs);
 shared_future& operator=(shared_future&& rhs);

 // retrieving the value
 R& get() const;

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <>
class shared_future<void>
{
public:
 shared_future();
 shared_future(const shared_future& rhs);
 shared_future(future<void>&&);
 shared_future(shared_future&& rhs);
 ~shared_future();
 shared_future& operator=(const shared_future& rhs);
 shared_future& operator=(shared_future&& rhs);

 // retrieving the value
 void get() const;

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <class R>
class atomic_future
{
public:
 atomic_future();
 atomic_future(const atomic_future& rhs);
 atomic_future(future<R>&&);
 ~atomic_future();
 atomic_future& operator=(const atomic_future& rhs);

 // retrieving the value
 const R& get() const;

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <class R>
class atomic_future<R&>
{
public:
 atomic_future();
 atomic_future(const atomic_future& rhs);
 atomic_future(future<R>&&);
 ~atomic_future();
 atomic_future& operator=(const atomic_future& rhs);

 // retrieving the value
 R& get() const;

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <>
class atomic_future<void>
{
public:
 atomic_future();
 atomic_future(const atomic_future& rhs);
 atomic_future(future<R>&&);
 ~atomic_future();
 atomic_future& operator=(const atomic_future& rhs);

 // retrieving the value
 void get() const;

 // functions to check state
 bool valid() const;

 void wait() const;
 template <class Rep, class Period>
 future_status
 wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 template <class Clock, class Duration>
 future_status
 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
};

template <class F, class... Args>
 future<typename result_of<F(Args...)>::type>
 async(F&& f, Args&&... args);

template <class F, class... Args>
 future<typename result_of<F(Args...)>::type>
 async(launch policy, F&& f, Args&&... args);

template <class> class packaged_task; // undefined

template <class R, class... ArgTypes>
class packaged_task<R(ArgTypes...)>
{
public:
 typedef R result_type;

 // construction and destruction
 packaged_task();
 template <class F>
 explicit packaged_task(F&& f);
 template <class F, class Allocator>
 explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
 ~packaged_task();

 // no copy
 packaged_task(packaged_task&) = delete;
 packaged_task& operator=(packaged_task&) = delete;

 // move support
 packaged_task(packaged_task&& other);
 packaged_task& operator=(packaged_task&& other);
 void swap(packaged_task& other);

 explicit operator bool() const;

 // result retrieval
 future<R> get_future();

 // execution
 void operator()(ArgTypes... );
 void make_ready_at_thread_exit(ArgTypes...);

 void reset();
};

template <class R>
 void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&);

template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;

} // std

*/

#include <__config>
#include <system_error>
#include <memory>
#include <chrono>
#include <exception>
#include <mutex>
#include <thread>

#pragma GCC system_header

_LIBCPP_BEGIN_NAMESPACE_STD

//enum class future_errc
struct future_errc
{
enum _ {
 broken_promise,
 future_already_retrieved,
 promise_already_satisfied,
 no_state
};

 _ __v_;

 future_errc(_ __v) : __v_(__v) {}
 operator int() const {return __v_;}

};

template <> struct is_error_code_enum<future_errc> : public true_type {};

//enum class launch
struct launch
{
enum _ {
 any,
 async,
 sync
};

 _ __v_;

 launch(_ __v) : __v_(__v) {}
 operator int() const {return __v_;}

};

//enum class future_status
struct future_status
{
enum _ {
 ready,
 timeout,
 deferred
};

 _ __v_;

 future_status(_ __v) : __v_(__v) {}
 operator int() const {return __v_;}

};

const error_category& future_category();

inline _LIBCPP_INLINE_VISIBILITY
error_code
make_error_code(future_errc __e)
{
 return error_code(static_cast<int>(__e), future_category());
}

inline _LIBCPP_INLINE_VISIBILITY
error_condition
make_error_condition(future_errc __e)
{
 return error_condition(static_cast<int>(__e), future_category());
}

class future_error
 : public logic_error
{
 error_code __ec_;
public:
 future_error(error_code __ec);

 const error_code& code() const throw() {return __ec_;}
};

class __assoc_sub_state
 : public __shared_count
{
protected:
 exception_ptr __exception_;
 mutable mutex __mut_;
 mutable condition_variable __cv_;
 unsigned __state_;

 virtual void __on_zero_shared();
 void __sub_wait(unique_lock<mutex>& __lk);
public:
 enum
 {
 __constructed = 1,
 __future_attached = 2,
 ready = 4,
 deferred = 8
 };

 __assoc_sub_state() : __state_(0) {}

 bool __has_value() const
 {return (__state_ & __constructed) || (__exception_ != nullptr);}

 void __set_future_attached() {__state_ |= __future_attached;}
 bool __has_future_attached() const {return __state_ & __future_attached;}

 void __set_deferred() {__state_ |= deferred;}

 void __make_ready();
 bool __is_ready() const {return __state_ & ready;}

 void set_value();
 void set_value_at_thread_exit();

 void set_exception(exception_ptr __p);
 void set_exception_at_thread_exit(exception_ptr __p);

 void copy();

 void wait();
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;

 virtual void __execute();
};

template <class _Clock, class _Duration>
future_status
__assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
{
 unique_lock<mutex> __lk(__mut_);
 if (__state_ & deferred)
 return future_status::deferred;
 while (!(__state_ & ready) && _Clock::now() < __abs_time)
 __cv_.wait_until(__lk, __abs_time);
 if (__state_ & ready)
 return future_status::ready;
 return future_status::timeout;
}

template <class _Rep, class _Period>
inline _LIBCPP_INLINE_VISIBILITY
future_status
__assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
{
 return wait_until(chrono::monotonic_clock::now() + __rel_time);
}

template <class _R>
class __assoc_state
 : public __assoc_sub_state
{
 typedef __assoc_sub_state base;
 typedef typename aligned_storage<sizeof(_R), alignment_of<_R>::value>::type _U;
protected:
 _U __value_;

 virtual void __on_zero_shared();
public:

 template <class _Arg>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 void set_value(_Arg&& __arg);
#else
 void set_value(_Arg& __arg);
#endif

 template <class _Arg>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 void set_value_at_thread_exit(_Arg&& __arg);
#else
 void set_value_at_thread_exit(_Arg& __arg);
#endif

 _R move();
 typename add_lvalue_reference<_R>::type copy();
};

template <class _R>
void
__assoc_state<_R>::__on_zero_shared()
{
 if (this->__state_ & base::__constructed)
 reinterpret_cast<_R*>(&__value_)->~_R();
 delete this;
}

template <class _R>
template <class _Arg>
void
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__assoc_state<_R>::set_value(_Arg&& __arg)
#else
__assoc_state<_R>::set_value(_Arg& __arg)
#endif
{
 unique_lock<mutex> __lk(this->__mut_);
 if (this->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 ::new(&__value_) _R(_STD::forward<_Arg>(__arg));
 this->__state_ |= base::__constructed | base::ready;
 __lk.unlock();
 __cv_.notify_all();
}

template <class _R>
template <class _Arg>
void
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__assoc_state<_R>::set_value_at_thread_exit(_Arg&& __arg)
#else
__assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg)
#endif
{
 unique_lock<mutex> __lk(this->__mut_);
 if (this->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 ::new(&__value_) _R(_STD::forward<_Arg>(__arg));
 this->__state_ |= base::__constructed;
 __thread_local_data->__make_ready_at_thread_exit(this);
 __lk.unlock();
}

template <class _R>
_R
__assoc_state<_R>::move()
{
 unique_lock<mutex> __lk(this->__mut_);
 this->__sub_wait(__lk);
 if (this->__exception_ != nullptr)
 rethrow_exception(this->__exception_);
 return _STD::move(*reinterpret_cast<_R*>(&__value_));
}

template <class _R>
typename add_lvalue_reference<_R>::type
__assoc_state<_R>::copy()
{
 unique_lock<mutex> __lk(this->__mut_);
 this->__sub_wait(__lk);
 if (this->__exception_ != nullptr)
 rethrow_exception(this->__exception_);
 return *reinterpret_cast<_R*>(&__value_);
}

template <class _R>
class __assoc_state<_R&>
 : public __assoc_sub_state
{
 typedef __assoc_sub_state base;
 typedef _R* _U;
protected:
 _U __value_;

 virtual void __on_zero_shared();
public:

 void set_value(_R& __arg);
 void set_value_at_thread_exit(_R& __arg);

 _R& copy();
};

template <class _R>
void
__assoc_state<_R&>::__on_zero_shared()
{
 delete this;
}

template <class _R>
void
__assoc_state<_R&>::set_value(_R& __arg)
{
 unique_lock<mutex> __lk(this->__mut_);
 if (this->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 __value_ = &__arg;
 this->__state_ |= base::__constructed | base::ready;
 __lk.unlock();
 __cv_.notify_all();
}

template <class _R>
void
__assoc_state<_R&>::set_value_at_thread_exit(_R& __arg)
{
 unique_lock<mutex> __lk(this->__mut_);
 if (this->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 __value_ = &__arg;
 this->__state_ |= base::__constructed;
 __thread_local_data->__make_ready_at_thread_exit(this);
 __lk.unlock();
}

template <class _R>
_R&
__assoc_state<_R&>::copy()
{
 unique_lock<mutex> __lk(this->__mut_);
 this->__sub_wait(__lk);
 if (this->__exception_ != nullptr)
 rethrow_exception(this->__exception_);
 return *__value_;
}

template <class _R, class _Alloc>
class __assoc_state_alloc
 : public __assoc_state<_R>
{
 typedef __assoc_state<_R> base;
 _Alloc __alloc_;

 virtual void __on_zero_shared();
public:
 explicit __assoc_state_alloc(const _Alloc& __a)
 : __alloc_(__a) {}
};

template <class _R, class _Alloc>
void
__assoc_state_alloc<_R, _Alloc>::__on_zero_shared()
{
 if (this->__state_ & base::__constructed)
 reinterpret_cast<_R*>(&this->__value_)->~_R();
 typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
 this->~__assoc_state_alloc();
 __a.deallocate(this, 1);
}

template <class _R, class _Alloc>
class __assoc_state_alloc<_R&, _Alloc>
 : public __assoc_state<_R&>
{
 typedef __assoc_state<_R&> base;
 _Alloc __alloc_;

 virtual void __on_zero_shared();
public:
 explicit __assoc_state_alloc(const _Alloc& __a)
 : __alloc_(__a) {}
};

template <class _R, class _Alloc>
void
__assoc_state_alloc<_R&, _Alloc>::__on_zero_shared()
{
 typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
 this->~__assoc_state_alloc();
 __a.deallocate(this, 1);
}

template <class _Alloc>
class __assoc_sub_state_alloc
 : public __assoc_sub_state
{
 typedef __assoc_sub_state base;
 _Alloc __alloc_;

 virtual void __on_zero_shared();
public:
 explicit __assoc_sub_state_alloc(const _Alloc& __a)
 : __alloc_(__a) {}
};

template <class _Alloc>
void
__assoc_sub_state_alloc<_Alloc>::__on_zero_shared()
{
 this->~base();
 typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_);
 this->~__assoc_sub_state_alloc();
 __a.deallocate(this, 1);
}

template <class _R, class _F>
class __deferred_assoc_state
 : public __assoc_state<_R>
{
 typedef __assoc_state<_R> base;

 _F __func_;

public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 explicit __deferred_assoc_state(_F&& __f);
#endif

 virtual void __execute();
};

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _R, class _F>
inline _LIBCPP_INLINE_VISIBILITY
__deferred_assoc_state<_R, _F>::__deferred_assoc_state(_F&& __f)
 : __func_(_STD::forward<_F>(__f))
{
 this->__set_deferred();
}

#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _R, class _F>
void
__deferred_assoc_state<_R, _F>::__execute()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 try
 {
#endif // _LIBCPP_NO_EXCEPTIONS
 this->set_value(__func_());
#ifndef _LIBCPP_NO_EXCEPTIONS
 }
 catch (...)
 {
 this->set_exception(current_exception());
 }
#endif // _LIBCPP_NO_EXCEPTIONS
}

template <class _F>
class __deferred_assoc_state<void, _F>
 : public __assoc_sub_state
{
 typedef __assoc_sub_state base;

 _F __func_;

public:
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 explicit __deferred_assoc_state(_F&& __f);
#endif

 virtual void __execute();
};

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _F>
inline _LIBCPP_INLINE_VISIBILITY
__deferred_assoc_state<void, _F>::__deferred_assoc_state(_F&& __f)
 : __func_(_STD::forward<_F>(__f))
{
 this->__set_deferred();
}

#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _F>
void
__deferred_assoc_state<void, _F>::__execute()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 try
 {
#endif // _LIBCPP_NO_EXCEPTIONS
 __func_();
 this->set_value();
#ifndef _LIBCPP_NO_EXCEPTIONS
 }
 catch (...)
 {
 this->set_exception(current_exception());
 }
#endif // _LIBCPP_NO_EXCEPTIONS
}

template <class> class promise;
template <class> class shared_future;
template <class> class atomic_future;

// future

template <class _R> class future;

template <class _R, class _F>
future<_R>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__make_deferred_assoc_state(_F&& __f);
#else
__make_deferred_assoc_state(_F __f);
#endif

template <class _R>
class future
{
 __assoc_state<_R>* __state_;

 explicit future(__assoc_state<_R>* __state);

 template <class> friend class promise;
 template <class> friend class shared_future;
 template <class> friend class atomic_future;

 template <class _R1, class _F>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 friend future<_R1> __make_deferred_assoc_state(_F&& __f);
#else
 friend future<_R1> __make_deferred_assoc_state(_F __f);
#endif

public:
 future() : __state_(nullptr) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 future(future&& __rhs)
 : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
 future(const future&) = delete;
 future& operator=(const future&) = delete;
 future& operator=(future&& __rhs)
 {
 future(std::move(__rhs)).swap(*this);
 return *this;
 }
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 future(const future&);
 future& operator=(const future&);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~future();

 // retrieving the value
 _R get();

 void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
future<_R>::future(__assoc_state<_R>* __state)
 : __state_(__state)
{
 if (__state_->__has_future_attached())
 throw future_error(make_error_code(future_errc::future_already_retrieved));
 __state_->__add_shared();
 __state_->__set_future_attached();
}

struct __release_shared_count
{
 void operator()(__shared_count* p) {p->__release_shared();}
};

template <class _R>
future<_R>::~future()
{
 if (__state_)
 __state_->__release_shared();
}

template <class _R>
_R
future<_R>::get()
{
 unique_ptr<__shared_count, __release_shared_count> __(__state_);
 __assoc_state<_R>* __s = __state_;
 __state_ = nullptr;
 return __s->move();
}

template <class _R>
class future<_R&>
{
 __assoc_state<_R&>* __state_;

 explicit future(__assoc_state<_R&>* __state);

 template <class> friend class promise;
 template <class> friend class shared_future;
 template <class> friend class atomic_future;

 template <class _R1, class _F>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 friend future<_R1> __make_deferred_assoc_state(_F&& __f);
#else
 friend future<_R1> __make_deferred_assoc_state(_F __f);
#endif

public:
 future() : __state_(nullptr) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 future(future&& __rhs)
 : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
 future(const future&) = delete;
 future& operator=(const future&) = delete;
 future& operator=(future&& __rhs)
 {
 future(std::move(__rhs)).swap(*this);
 return *this;
 }
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 future(const future&);
 future& operator=(const future&);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~future();

 // retrieving the value
 _R& get();

 void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
future<_R&>::future(__assoc_state<_R&>* __state)
 : __state_(__state)
{
 if (__state_->__has_future_attached())
 throw future_error(make_error_code(future_errc::future_already_retrieved));
 __state_->__add_shared();
 __state_->__set_future_attached();
}

template <class _R>
future<_R&>::~future()
{
 if (__state_)
 __state_->__release_shared();
}

template <class _R>
_R&
future<_R&>::get()
{
 unique_ptr<__shared_count, __release_shared_count> __(__state_);
 __assoc_state<_R&>* __s = __state_;
 __state_ = nullptr;
 return __s->copy();
}

template <>
class future<void>
{
 __assoc_sub_state* __state_;

 explicit future(__assoc_sub_state* __state);

 template <class> friend class promise;
 template <class> friend class shared_future;
 template <class> friend class atomic_future;

 template <class _R1, class _F>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 friend future<_R1> __make_deferred_assoc_state(_F&& __f);
#else
 friend future<_R1> __make_deferred_assoc_state(_F __f);
#endif

public:
 future() : __state_(nullptr) {}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 future(future&& __rhs)
 : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
 future(const future&) = delete;
 future& operator=(const future&) = delete;
 future& operator=(future&& __rhs)
 {
 future(std::move(__rhs)).swap(*this);
 return *this;
 }
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 future(const future&);
 future& operator=(const future&);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~future();

 // retrieving the value
 void get();

 void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(future<_R>& __x, future<_R>& __y)
{
 __x.swap(__y);
}

// promise<R>

template <class> class packaged_task;

template <class _R>
class promise
{
 __assoc_state<_R>* __state_;

 explicit promise(nullptr_t) : __state_(nullptr) {}

 template <class> friend class packaged_task;
public:
 promise();
 template <class _Alloc>
 promise(allocator_arg_t, const _Alloc& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 promise(promise&& __rhs)
 : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
 promise(const promise& __rhs) = delete;
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 promise(const promise& __rhs);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~promise();

 // assignment
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 promise& operator=(promise&& __rhs)
 {
 promise(std::move(__rhs)).swap(*this);
 return *this;
 }
 promise& operator=(const promise& __rhs) = delete;
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 promise& operator=(const promise& __rhs);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // retrieving the result
 future<_R> get_future();

 // setting the result
 void set_value(const _R& __r);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 void set_value(_R&& __r);
#endif
 void set_exception(exception_ptr __p);

 // setting the result with deferred notification
 void set_value_at_thread_exit(const _R& __r);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 void set_value_at_thread_exit(_R&& __r);
#endif
 void set_exception_at_thread_exit(exception_ptr __p);
};

template <class _R>
promise<_R>::promise()
 : __state_(new __assoc_state<_R>)
{
}

template <class _R>
template <class _Alloc>
promise<_R>::promise(allocator_arg_t, const _Alloc& __a0)
{
 typedef typename _Alloc::template rebind<__assoc_state_alloc<_R, _Alloc> >::other _A2;
 typedef __allocator_destructor<_A2> _D2;
 _A2 __a(__a0);
 unique_ptr<__assoc_state_alloc<_R, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
 ::new(__hold.get()) __assoc_state_alloc<_R, _Alloc>(__a0);
 __state_ = __hold.release();
}

template <class _R>
promise<_R>::~promise()
{
 if (__state_)
 {
 if (!__state_->__has_value() && __state_->use_count() > 1)
 __state_->set_exception(make_exception_ptr(
 future_error(make_error_code(future_errc::broken_promise))
 ));
 __state_->__release_shared();
 }
}

template <class _R>
future<_R>
promise<_R>::get_future()
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 return future<_R>(__state_);
}

template <class _R>
void
promise<_R>::set_value(const _R& __r)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_value(__r);
}

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _R>
void
promise<_R>::set_value(_R&& __r)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_value(_STD::move(__r));
}

#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _R>
void
promise<_R>::set_exception(exception_ptr __p)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_exception(__p);
}

template <class _R>
void
promise<_R>::set_value_at_thread_exit(const _R& __r)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_value_at_thread_exit(__r);
}

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _R>
void
promise<_R>::set_value_at_thread_exit(_R&& __r)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_value_at_thread_exit(_STD::move(__r));
}

#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _R>
void
promise<_R>::set_exception_at_thread_exit(exception_ptr __p)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_exception_at_thread_exit(__p);
}

// promise<R&>

template <class _R>
class promise<_R&>
{
 __assoc_state<_R&>* __state_;

 explicit promise(nullptr_t) : __state_(nullptr) {}

 template <class> friend class packaged_task;

public:
 promise();
 template <class _Allocator>
 promise(allocator_arg_t, const _Allocator& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 promise(promise&& __rhs)
 : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
 promise(const promise& __rhs) = delete;
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 promise(const promise& __rhs);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~promise();

 // assignment
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 promise& operator=(promise&& __rhs)
 {
 promise(std::move(__rhs)).swap(*this);
 return *this;
 }
 promise& operator=(const promise& __rhs) = delete;
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 promise& operator=(const promise& __rhs);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // retrieving the result
 future<_R&> get_future();

 // setting the result
 void set_value(_R& __r);
 void set_exception(exception_ptr __p);

 // setting the result with deferred notification
 void set_value_at_thread_exit(_R&);
 void set_exception_at_thread_exit(exception_ptr __p);
};

template <class _R>
promise<_R&>::promise()
 : __state_(new __assoc_state<_R&>)
{
}

template <class _R>
template <class _Alloc>
promise<_R&>::promise(allocator_arg_t, const _Alloc& __a0)
{
 typedef typename _Alloc::template rebind<__assoc_state_alloc<_R&, _Alloc> >::other _A2;
 typedef __allocator_destructor<_A2> _D2;
 _A2 __a(__a0);
 unique_ptr<__assoc_state_alloc<_R&, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
 ::new(__hold.get()) __assoc_state_alloc<_R&, _Alloc>(__a0);
 __state_ = __hold.release();
}

template <class _R>
promise<_R&>::~promise()
{
 if (__state_)
 {
 if (!__state_->__has_value() && __state_->use_count() > 1)
 __state_->set_exception(make_exception_ptr(
 future_error(make_error_code(future_errc::broken_promise))
 ));
 __state_->__release_shared();
 }
}

template <class _R>
future<_R&>
promise<_R&>::get_future()
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 return future<_R&>(__state_);
}

template <class _R>
void
promise<_R&>::set_value(_R& __r)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_value(__r);
}

template <class _R>
void
promise<_R&>::set_exception(exception_ptr __p)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_exception(__p);
}

template <class _R>
void
promise<_R&>::set_value_at_thread_exit(_R& __r)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_value_at_thread_exit(__r);
}

template <class _R>
void
promise<_R&>::set_exception_at_thread_exit(exception_ptr __p)
{
 if (__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 __state_->set_exception_at_thread_exit(__p);
}

// promise<void>

template <>
class promise<void>
{
 __assoc_sub_state* __state_;

 explicit promise(nullptr_t) : __state_(nullptr) {}

 template <class> friend class packaged_task;

public:
 promise();
 template <class _Allocator>
 promise(allocator_arg_t, const _Allocator& __a);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 promise(promise&& __rhs)
 : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
 promise(const promise& __rhs) = delete;
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 promise(const promise& __rhs);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~promise();

 // assignment
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 promise& operator=(promise&& __rhs)
 {
 promise(std::move(__rhs)).swap(*this);
 return *this;
 }
 promise& operator=(const promise& __rhs) = delete;
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
private:
 promise& operator=(const promise& __rhs);
public:
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // retrieving the result
 future<void> get_future();

 // setting the result
 void set_value();
 void set_exception(exception_ptr __p);

 // setting the result with deferred notification
 void set_value_at_thread_exit();
 void set_exception_at_thread_exit(exception_ptr __p);
};

template <class _Alloc>
promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
{
 typedef typename _Alloc::template rebind<__assoc_sub_state_alloc<_Alloc> >::other _A2;
 typedef __allocator_destructor<_A2> _D2;
 _A2 __a(__a0);
 unique_ptr<__assoc_sub_state_alloc<_Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
 ::new(__hold.get()) __assoc_sub_state_alloc<_Alloc>(__a0);
 __state_ = __hold.release();
}

template <class _R>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(promise<_R>& __x, promise<_R>& __y)
{
 __x.swap(__y);
}

template <class _R, class _Alloc>
 struct uses_allocator<promise<_R>, _Alloc> : public true_type {};

#ifndef _LIBCPP_HAS_NO_VARIADICS

// packaged_task

template<class _Fp> class __packaged_task_base;

template<class _R, class ..._ArgTypes>
class __packaged_task_base<_R(_ArgTypes...)>
{
 __packaged_task_base(const __packaged_task_base&);
 __packaged_task_base& operator=(const __packaged_task_base&);
public:
 __packaged_task_base() {}
 virtual ~__packaged_task_base() {}
 virtual void __move_to(__packaged_task_base*) = 0;
 virtual void destroy() = 0;
 virtual void destroy_deallocate() = 0;
 virtual _R operator()(_ArgTypes&& ...) = 0;
};

template<class _FD, class _Alloc, class _FB> class __packaged_task_func;

template<class _F, class _Alloc, class _R, class ..._ArgTypes>
class __packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>
 : public __packaged_task_base<_R(_ArgTypes...)>
{
 __compressed_pair<_F, _Alloc> __f_;
public:
 explicit __packaged_task_func(const _F& __f) : __f_(__f) {}
 explicit __packaged_task_func(_F&& __f) : __f_(_STD::move(__f)) {}
 __packaged_task_func(const _F& __f, const _Alloc& __a)
 : __f_(__f, __a) {}
 __packaged_task_func(_F&& __f, const _Alloc& __a)
 : __f_(_STD::move(__f), __a) {}
 virtual void __move_to(__packaged_task_base<_R(_ArgTypes...)>*);
 virtual void destroy();
 virtual void destroy_deallocate();
 virtual _R operator()(_ArgTypes&& ... __args);
};

template<class _F, class _Alloc, class _R, class ..._ArgTypes>
void
__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::__move_to(
 __packaged_task_base<_R(_ArgTypes...)>* __p)
{
 ::new (__p) __packaged_task_func(_STD::move(__f_.first()), _STD::move(__f_.second()));
}

template<class _F, class _Alloc, class _R, class ..._ArgTypes>
void
__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::destroy()
{
 __f_.~__compressed_pair<_F, _Alloc>();
}

template<class _F, class _Alloc, class _R, class ..._ArgTypes>
void
__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate()
{
 typedef typename _Alloc::template rebind<__packaged_task_func>::other _A;
 _A __a(__f_.second());
 __f_.~__compressed_pair<_F, _Alloc>();
 __a.deallocate(this, 1);
}

template<class _F, class _Alloc, class _R, class ..._ArgTypes>
_R
__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
{
 return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
}

template <class> class __packaged_task_function;

template<class _R, class ..._ArgTypes>
class __packaged_task_function<_R(_ArgTypes...)>
{
 typedef __packaged_task_base<_R(_ArgTypes...)> __base;
 aligned_storage<3*sizeof(void*)>::type __buf_;
 __base* __f_;

public:
 typedef _R result_type;

 // construct/copy/destroy:
 __packaged_task_function() : __f_(nullptr) {}
 template<class _F>
 __packaged_task_function(_F&& __f);
 template<class _F, class _Alloc>
 __packaged_task_function(allocator_arg_t, const _Alloc& __a, _F&& __f);

 __packaged_task_function(__packaged_task_function&&);
 __packaged_task_function& operator=(__packaged_task_function&&);

 __packaged_task_function(const __packaged_task_function&) = delete;
 __packaged_task_function& operator=(const __packaged_task_function&) = delete;

 ~__packaged_task_function();

 void swap(__packaged_task_function&);

 _R operator()(_ArgTypes...) const;
};

template<class _R, class ..._ArgTypes>
__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f)
{
 if (__f.__f_ == nullptr)
 __f_ = nullptr;
 else if (__f.__f_ == (__base*)&__f.__buf_)
 {
 __f_ = (__base*)&__buf_;
 __f.__f_->__move_to(__f_);
 }
 else
 {
 __f_ = __f.__f_;
 __f.__f_ = nullptr;
 }
}

template<class _R, class ..._ArgTypes>
template <class _F>
__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f)
 : __f_(nullptr)
{
 typedef typename remove_reference<_F>::type _FR;
 typedef __packaged_task_func<_FR, allocator<_FR>, _R(_ArgTypes...)> _FF;
 if (sizeof(_FF) <= sizeof(__buf_))
 {
 __f_ = (__base*)&__buf_;
 ::new (__f_) _FF(_STD::forward<_F>(__f));
 }
 else
 {
 typedef allocator<_FF> _A;
 _A __a;
 typedef __allocator_destructor<_A> _D;
 unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
 ::new (__hold.get()) _FF(_STD::forward<_F>(__f), allocator<_FR>(__a));
 __f_ = __hold.release();
 }
}

template<class _R, class ..._ArgTypes>
template <class _F, class _Alloc>
__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
 allocator_arg_t, const _Alloc& __a0, _F&& __f)
 : __f_(nullptr)
{
 typedef allocator_traits<_Alloc> __alloc_traits;
 typedef typename remove_reference<_F>::type _FR;
 typedef __packaged_task_func<_FR, _Alloc, _R(_ArgTypes...)> _FF;
 if (sizeof(_FF) <= sizeof(__buf_))
 {
 __f_ = (__base*)&__buf_;
 ::new (__f_) _FF(_STD::forward<_F>(__f));
 }
 else
 {
 typedef typename __alloc_traits::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
 rebind_alloc<_FF>
#else
 rebind_alloc<_FF>::other
#endif
 _A;
 _A __a(__a0);
 typedef __allocator_destructor<_A> _D;
 unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
 ::new (__hold.get()) _FF(_STD::forward<_F>(__f), _Alloc(__a));
 __f_ = __hold.release();
 }
}

template<class _R, class ..._ArgTypes>
__packaged_task_function<_R(_ArgTypes...)>&
__packaged_task_function<_R(_ArgTypes...)>::operator=(__packaged_task_function&& __f)
{
 if (__f_ == (__base*)&__buf_)
 __f_->destroy();
 else if (__f_)
 __f_->destroy_deallocate();
 __f_ = nullptr;
 if (__f.__f_ == nullptr)
 __f_ = nullptr;
 else if (__f.__f_ == (__base*)&__f.__buf_)
 {
 __f_ = (__base*)&__buf_;
 __f.__f_->__move_to(__f_);
 }
 else
 {
 __f_ = __f.__f_;
 __f.__f_ = nullptr;
 }
}

template<class _R, class ..._ArgTypes>
__packaged_task_function<_R(_ArgTypes...)>::~__packaged_task_function()
{
 if (__f_ == (__base*)&__buf_)
 __f_->destroy();
 else if (__f_)
 __f_->destroy_deallocate();
}

template<class _R, class ..._ArgTypes>
void
__packaged_task_function<_R(_ArgTypes...)>::swap(__packaged_task_function& __f)
{
 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
 {
 typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
 __base* __t = (__base*)&__tempbuf;
 __f_->__move_to(__t);
 __f_->destroy();
 __f_ = nullptr;
 __f.__f_->__move_to((__base*)&__buf_);
 __f.__f_->destroy();
 __f.__f_ = nullptr;
 __f_ = (__base*)&__buf_;
 __t->__move_to((__base*)&__f.__buf_);
 __t->destroy();
 __f.__f_ = (__base*)&__f.__buf_;
 }
 else if (__f_ == (__base*)&__buf_)
 {
 __f_->__move_to((__base*)&__f.__buf_);
 __f_->destroy();
 __f_ = __f.__f_;
 __f.__f_ = (__base*)&__f.__buf_;
 }
 else if (__f.__f_ == (__base*)&__f.__buf_)
 {
 __f.__f_->__move_to((__base*)&__buf_);
 __f.__f_->destroy();
 __f.__f_ = __f_;
 __f_ = (__base*)&__buf_;
 }
 else
 _STD::swap(__f_, __f.__f_);
}

template<class _R, class ..._ArgTypes>
inline _LIBCPP_INLINE_VISIBILITY
_R
__packaged_task_function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
{
 return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
}

template<class _R, class ..._ArgTypes>
class packaged_task<_R(_ArgTypes...)>
{
public:
 typedef _R result_type;

private:
 __packaged_task_function<result_type(_ArgTypes...)> __f_;
 promise<result_type> __p_;

public:
 // construction and destruction
 packaged_task() : __p_(nullptr) {}
 template <class _F>
 explicit packaged_task(_F&& __f) : __f_(_STD::forward<_F>(__f)) {}
 template <class _F, class _Allocator>
 explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
 : __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
 __p_(allocator_arg, __a) {}
 // ~packaged_task() = default;

 // no copy
 packaged_task(packaged_task&) = delete;
 packaged_task& operator=(packaged_task&) = delete;

 // move support
 packaged_task(packaged_task&& __other)
 : __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
 packaged_task& operator=(packaged_task&& __other)
 {
 __f_ = _STD::move(__other.__f_);
 __p_ = _STD::move(__other.__p_);
 return *this;
 }
 void swap(packaged_task& __other)
 {
 __f_.swap(__other.__f_);
 __p_.swap(__other.__p_);
 }

 //explicit
 operator bool() const {return __p_.__state_ != nullptr;}

 // result retrieval
 future<result_type> get_future() {return __p_.get_future();}

 // execution
 void operator()(_ArgTypes... __args);
 void make_ready_at_thread_exit(_ArgTypes... __args);

 void reset();
};

template<class _R, class ..._ArgTypes>
void
packaged_task<_R(_ArgTypes...)>::operator()(_ArgTypes... __args)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 if (__p_.__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 if (__p_.__state_->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 try
 {
#endif // _LIBCPP_NO_EXCEPTIONS
 __p_.set_value(__f_(_STD::forward<_ArgTypes>(__args)...));
#ifndef _LIBCPP_NO_EXCEPTIONS
 }
 catch (...)
 {
 __p_.set_exception(current_exception());
 }
#endif // _LIBCPP_NO_EXCEPTIONS
}

template<class _R, class ..._ArgTypes>
void
packaged_task<_R(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 if (__p_.__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 if (__p_.__state_->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 try
 {
#endif // _LIBCPP_NO_EXCEPTIONS
 __p_.set_value_at_thread_exit(__f_(_STD::forward<_ArgTypes>(__args)...));
#ifndef _LIBCPP_NO_EXCEPTIONS
 }
 catch (...)
 {
 __p_.set_exception_at_thread_exit(current_exception());
 }
#endif // _LIBCPP_NO_EXCEPTIONS
}

template<class _R, class ..._ArgTypes>
void
packaged_task<_R(_ArgTypes...)>::reset()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 if (!(*this))
 throw future_error(make_error_code(future_errc::no_state));
#endif // _LIBCPP_NO_EXCEPTIONS
 __p_ = promise<result_type>();
}

template<class ..._ArgTypes>
class packaged_task<void(_ArgTypes...)>
{
public:
 typedef void result_type;

private:
 __packaged_task_function<result_type(_ArgTypes...)> __f_;
 promise<result_type> __p_;

public:
 // construction and destruction
 packaged_task() : __p_(nullptr) {}
 template <class _F>
 explicit packaged_task(_F&& __f) : __f_(_STD::forward<_F>(__f)) {}
 template <class _F, class _Allocator>
 explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
 : __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
 __p_(allocator_arg, __a) {}
 // ~packaged_task() = default;

 // no copy
 packaged_task(packaged_task&) = delete;
 packaged_task& operator=(packaged_task&) = delete;

 // move support
 packaged_task(packaged_task&& __other)
 : __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
 packaged_task& operator=(packaged_task&& __other)
 {
 __f_ = _STD::move(__other.__f_);
 __p_ = _STD::move(__other.__p_);
 return *this;
 }
 void swap(packaged_task& __other)
 {
 __f_.swap(__other.__f_);
 __p_.swap(__other.__p_);
 }

 //explicit
 operator bool() const {return __p_.__state_ != nullptr;}

 // result retrieval
 future<result_type> get_future() {return __p_.get_future();}

 // execution
 void operator()(_ArgTypes... __args);
 void make_ready_at_thread_exit(_ArgTypes... __args);

 void reset();
};

template<class ..._ArgTypes>
void
packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 if (__p_.__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 if (__p_.__state_->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 try
 {
#endif // _LIBCPP_NO_EXCEPTIONS
 __f_(_STD::forward<_ArgTypes>(__args)...);
 __p_.set_value();
#ifndef _LIBCPP_NO_EXCEPTIONS
 }
 catch (...)
 {
 __p_.set_exception(current_exception());
 }
#endif // _LIBCPP_NO_EXCEPTIONS
}

template<class ..._ArgTypes>
void
packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 if (__p_.__state_ == nullptr)
 throw future_error(make_error_code(future_errc::no_state));
 if (__p_.__state_->__has_value())
 throw future_error(make_error_code(future_errc::promise_already_satisfied));
 try
 {
#endif // _LIBCPP_NO_EXCEPTIONS
 __f_(_STD::forward<_ArgTypes>(__args)...);
 __p_.set_value_at_thread_exit();
#ifndef _LIBCPP_NO_EXCEPTIONS
 }
 catch (...)
 {
 __p_.set_exception_at_thread_exit(current_exception());
 }
#endif // _LIBCPP_NO_EXCEPTIONS
}

template<class ..._ArgTypes>
void
packaged_task<void(_ArgTypes...)>::reset()
{
#ifndef _LIBCPP_NO_EXCEPTIONS
 if (!(*this))
 throw future_error(make_error_code(future_errc::no_state));
#endif // _LIBCPP_NO_EXCEPTIONS
 __p_ = promise<result_type>();
}

template <class _Callable>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y)
{
 __x.swap(__y);
}

template <class _Callable, class _Alloc>
struct uses_allocator<packaged_task<_Callable>, _Alloc> : public true_type {};

template <class _R, class _F>
future<_R>
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
__make_deferred_assoc_state(_F&& __f)
#else
__make_deferred_assoc_state(_F __f)
#endif
{
 unique_ptr<__deferred_assoc_state<_R, _F>, __release_shared_count>
 __h(new __deferred_assoc_state<_R, _F>(_STD::forward<_F>(__f)));
 return future<_R>(__h.get());
}

template <class _F, class... _Args>
future<typename result_of<_F(_Args...)>::type>
async(launch __policy, _F&& __f, _Args&&... __args)
{
 typedef typename result_of<_F(_Args...)>::type _R;
 future<_R> __r;
 if (__policy == launch::sync)
 __r = _STD::__make_deferred_assoc_state<_R>(bind(_STD::forward<_F>(__f),
 _STD::forward<_Args>(__args)...));
 else
 {
 packaged_task<_R()> __pk(bind(_STD::forward<_F>(__f),
 _STD::forward<_Args>(__args)...));
 __r = __pk.get_future();
 thread(_STD::move(__pk)).detach();
 }
 return __r;
}

template <class _F, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
typename enable_if
<
 !is_same<typename decay<_F>::type, launch>::value,
 future<typename result_of<_F(_Args...)>::type>
>::type
async(_F&& __f, _Args&&... __args)
{
 return async(launch::any, _STD::forward<_F>(__f),
 _STD::forward<_Args>(__args)...);
}

#endif // _LIBCPP_HAS_NO_VARIADICS

// shared_future

template <class _R>
class shared_future
{
 __assoc_state<_R>* __state_;

public:
 shared_future() : __state_(nullptr) {}
 shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
 {if (__state_) __state_->__add_shared();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_future(future<_R>&& __f) : __state_(__f.__state_)
 {__f.__state_ = nullptr;}
 shared_future(shared_future&& __rhs) : __state_(__rhs.__state_)
 {__rhs.__state_ = nullptr;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~shared_future();
 shared_future& operator=(const shared_future& __rhs);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_future& operator=(shared_future&& __rhs)
 {
 shared_future(std::move(__rhs)).swap(*this);
 return *this;
 }
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 // retrieving the value
 const _R& get() const {return __state_->copy();}

 void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
shared_future<_R>::~shared_future()
{
 if (__state_)
 __state_->__release_shared();
}

template <class _R>
shared_future<_R>&
shared_future<_R>::operator=(const shared_future& __rhs)
{
 if (__rhs.__state_)
 __rhs.__state_->__add_shared();
 if (__state_)
 __state_->__release_shared();
 __state_ = __rhs.__state_;
 return *this;
}

template <class _R>
class shared_future<_R&>
{
 __assoc_state<_R&>* __state_;

public:
 shared_future() : __state_(nullptr) {}
 shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
 {if (__state_) __state_->__add_shared();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_future(future<_R&>&& __f) : __state_(__f.__state_)
 {__f.__state_ = nullptr;}
 shared_future(shared_future&& __rhs) : __state_(__rhs.__state_)
 {__rhs.__state_ = nullptr;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~shared_future();
 shared_future& operator=(const shared_future& __rhs);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_future& operator=(shared_future&& __rhs)
 {
 shared_future(std::move(__rhs)).swap(*this);
 return *this;
 }
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 // retrieving the value
 _R& get() const {return __state_->copy();}

 void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
shared_future<_R&>::~shared_future()
{
 if (__state_)
 __state_->__release_shared();
}

template <class _R>
shared_future<_R&>&
shared_future<_R&>::operator=(const shared_future& __rhs)
{
 if (__rhs.__state_)
 __rhs.__state_->__add_shared();
 if (__state_)
 __state_->__release_shared();
 __state_ = __rhs.__state_;
 return *this;
}

template <>
class shared_future<void>
{
 __assoc_sub_state* __state_;

public:
 shared_future() : __state_(nullptr) {}
 shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
 {if (__state_) __state_->__add_shared();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_future(future<void>&& __f) : __state_(__f.__state_)
 {__f.__state_ = nullptr;}
 shared_future(shared_future&& __rhs) : __state_(__rhs.__state_)
 {__rhs.__state_ = nullptr;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~shared_future();
 shared_future& operator=(const shared_future& __rhs);
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 shared_future& operator=(shared_future&& __rhs)
 {
 shared_future(std::move(__rhs)).swap(*this);
 return *this;
 }
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 // retrieving the value
 void get() const {__state_->copy();}

 void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(shared_future<_R>& __x, shared_future<_R>& __y)
{
 __x.swap(__y);
}

// atomic_future

template <class _R>
class atomic_future
{
 __assoc_state<_R>* __state_;
 mutable mutex __mut_;

public:
 atomic_future() : __state_(nullptr) {}
 atomic_future(const atomic_future& __rhs) : __state_(__rhs.__state_)
 {if (__state_) __state_->__add_shared();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 atomic_future(future<_R>&& __f) : __state_(__f.__state_)
 {__f.__state_ = nullptr;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~atomic_future();
 atomic_future& operator=(const atomic_future& __rhs);

 // retrieving the value
 const _R& get() const {return __state_->copy();}

 void swap(atomic_future& __rhs);

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
atomic_future<_R>::~atomic_future()
{
 if (__state_)
 __state_->__release_shared();
}

template <class _R>
atomic_future<_R>&
atomic_future<_R>::operator=(const atomic_future& __rhs)
{
 if (this != &__rhs)
 {
 unique_lock<mutex> __this(__mut_, defer_lock);
 unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
 _STD::lock(__this, __that);
 if (__rhs.__state_)
 __rhs.__state_->__add_shared();
 if (__state_)
 __state_->__release_shared();
 __state_ = __rhs.__state_;
 }
 return *this;
}

template <class _R>
void
atomic_future<_R>::swap(atomic_future& __rhs)
{
 if (this != &__rhs)
 {
 unique_lock<mutex> __this(__mut_, defer_lock);
 unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
 _STD::lock(__this, __that);
 _STD::swap(__state_, __rhs.__state_);
 }
}

template <class _R>
class atomic_future<_R&>
{
 __assoc_state<_R&>* __state_;
 mutable mutex __mut_;

public:
 atomic_future() : __state_(nullptr) {}
 atomic_future(const atomic_future& __rhs) : __state_(__rhs.__state_)
 {if (__state_) __state_->__add_shared();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 atomic_future(future<_R&>&& __f) : __state_(__f.__state_)
 {__f.__state_ = nullptr;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~atomic_future();
 atomic_future& operator=(const atomic_future& __rhs);

 // retrieving the value
 _R& get() const {return __state_->copy();}

 void swap(atomic_future& __rhs);

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
atomic_future<_R&>::~atomic_future()
{
 if (__state_)
 __state_->__release_shared();
}

template <class _R>
atomic_future<_R&>&
atomic_future<_R&>::operator=(const atomic_future& __rhs)
{
 if (this != &__rhs)
 {
 unique_lock<mutex> __this(__mut_, defer_lock);
 unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
 _STD::lock(__this, __that);
 if (__rhs.__state_)
 __rhs.__state_->__add_shared();
 if (__state_)
 __state_->__release_shared();
 __state_ = __rhs.__state_;
 }
 return *this;
}

template <class _R>
void
atomic_future<_R&>::swap(atomic_future& __rhs)
{
 if (this != &__rhs)
 {
 unique_lock<mutex> __this(__mut_, defer_lock);
 unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
 _STD::lock(__this, __that);
 _STD::swap(__state_, __rhs.__state_);
 }
}

template <>
class atomic_future<void>
{
 __assoc_sub_state* __state_;
 mutable mutex __mut_;

public:
 atomic_future() : __state_(nullptr) {}
 atomic_future(const atomic_future& __rhs) : __state_(__rhs.__state_)
 {if (__state_) __state_->__add_shared();}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 atomic_future(future<void>&& __f) : __state_(__f.__state_)
 {__f.__state_ = nullptr;}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 ~atomic_future();
 atomic_future& operator=(const atomic_future& __rhs);

 // retrieving the value
 void get() const {__state_->copy();}

 void swap(atomic_future& __rhs);

 // functions to check state
 bool valid() const {return __state_ != nullptr;}

 void wait() const {__state_->wait();}
 template <class _Rep, class _Period>
 future_status
 wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {return __state_->wait_for(__rel_time);}
 template <class _Clock, class _Duration>
 future_status
 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 {return __state_->wait_until(__abs_time);}
};

template <class _R>
inline _LIBCPP_INLINE_VISIBILITY
void
swap(atomic_future<_R>& __x, atomic_future<_R>& __y)
{
 __x.swap(__y);
}

_LIBCPP_END_NAMESPACE_STD

#endif // _LIBCPP_FUTURE