// -*- C++ -*-

//===--------------------------- future -----------------------------------===//

//

// The LLVM Compiler Infrastructure

//

// This file is dual licensed under the MIT and the University of Illinois Open

// Source Licenses. See LICENSE.TXT for details.

//

//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_FUTURE

#define _LIBCPP_FUTURE

/*

future synopsis

namespace std

{

enum class future_errc

{

future_already_retrieved = 1,

promise_already_satisfied,

no_state,

broken_promise

};

enum class launch

{

async = 1,

deferred = 2,

any = async | deferred

};

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) noexcept;

error_condition make_error_condition(future_errc e) noexcept;

const error_category& future_category() noexcept;

class future_error

: public logic_error

{

public:

future_error(error_code ec); // exposition only

const error_code& code() const noexcept;

const char* what() const noexcept;

};

template <class R>

class promise

{

public:

promise();

template <class Allocator>

promise(allocator_arg_t, const Allocator& a);

promise(promise&& rhs) noexcept;

promise(const promise& rhs) = delete;

~promise();

// assignment

promise& operator=(promise&& rhs) noexcept;

promise& operator=(const promise& rhs) = delete;

void swap(promise& other) noexcept;

// 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) noexcept;

promise(const promise& rhs) = delete;

~promise();

// assignment

promise& operator=(promise&& rhs) noexcept;

promise& operator=(const promise& rhs) = delete;

void swap(promise& other) noexcept;

// 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) noexcept;

promise(const promise& rhs) = delete;

~promise();

// assignment

promise& operator=(promise&& rhs) noexcept;

promise& operator=(const promise& rhs) = delete;

void swap(promise& other) noexcept;

// 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) noexcept;

template <class R, class Alloc>

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

template <class R>

class future

{

public:

future() noexcept;

future(future&&) noexcept;

future(const future& rhs) = delete;

~future();

future& operator=(const future& rhs) = delete;

future& operator=(future&&) noexcept;

shared_future<R> share();

// retrieving the value

R get();

// functions to check state

bool valid() const noexcept;

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() noexcept;

future(future&&) noexcept;

future(const future& rhs) = delete;

~future();

future& operator=(const future& rhs) = delete;

future& operator=(future&&) noexcept;

shared_future<R&> share();

// retrieving the value

R& get();

// functions to check state

bool valid() const noexcept;

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() noexcept;

future(future&&) noexcept;

future(const future& rhs) = delete;

~future();

future& operator=(const future& rhs) = delete;

future& operator=(future&&) noexcept;

shared_future<void> share();

// retrieving the value

void get();

// functions to check state

bool valid() const noexcept;

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() noexcept;

shared_future(const shared_future& rhs);

shared_future(future<R>&&) noexcept;

shared_future(shared_future&& rhs) noexcept;

~shared_future();

shared_future& operator=(const shared_future& rhs);

shared_future& operator=(shared_future&& rhs) noexcept;

// retrieving the value

const R& get() const;

// functions to check state

bool valid() const noexcept;

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() noexcept;

shared_future(const shared_future& rhs);

shared_future(future<R&>&&) noexcept;

shared_future(shared_future&& rhs) noexcept;

~shared_future();

shared_future& operator=(const shared_future& rhs);

shared_future& operator=(shared_future&& rhs) noexcept;

// retrieving the value

R& get() const;

// functions to check state

bool valid() const noexcept;

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() noexcept;

shared_future(const shared_future& rhs);

shared_future(future<void>&&) noexcept;

shared_future(shared_future&& rhs) noexcept;

~shared_future();

shared_future& operator=(const shared_future& rhs);

shared_future& operator=(shared_future&& rhs) noexcept;

// retrieving the value

void get() const;

// functions to check state

bool valid() const noexcept;

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<typename decay<F>::type(typename decay<Args>::type...)>::type>

async(F&& f, Args&&... args);

template <class F, class... Args>

future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::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() noexcept;

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(const packaged_task&) = delete;

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

// move support

packaged_task(packaged_task&& other) noexcept;

packaged_task& operator=(packaged_task&& other) noexcept;

void swap(packaged_task& other) noexcept;

bool valid() const noexcept;

// 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...)>&) noexcept;

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>

#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

#pragma GCC system_header

#endif

#ifdef _LIBCPP_HAS_NO_THREADS

#error <future> is not supported on this single threaded system

#else // !_LIBCPP_HAS_NO_THREADS

_LIBCPP_BEGIN_NAMESPACE_STD

//enum class future_errc

_LIBCPP_DECLARE_STRONG_ENUM(future_errc)

{

future_already_retrieved = 1,

promise_already_satisfied,

no_state,

broken_promise

};

_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)

template <>

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

#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS

template <>

struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum<future_errc::__lx> : public true_type { };

#endif

//enum class launch

_LIBCPP_DECLARE_STRONG_ENUM(launch)

{

async = 1,

deferred = 2,

any = async | deferred

};

_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)

#ifndef _LIBCPP_HAS_NO_STRONG_ENUMS

#ifdef _LIBCXX_UNDERLYING_TYPE

typedef underlying_type<launch>::type __launch_underlying_type;

#else

typedef int __launch_underlying_type;

#endif

inline _LIBCPP_INLINE_VISIBILITY

_LIBCPP_CONSTEXPR

launch

operator&(launch __x, launch __y)

{

return static_cast<launch>(static_cast<__launch_underlying_type>(__x) &

static_cast<__launch_underlying_type>(__y));

}

inline _LIBCPP_INLINE_VISIBILITY

_LIBCPP_CONSTEXPR

launch

operator|(launch __x, launch __y)

{

return static_cast<launch>(static_cast<__launch_underlying_type>(__x) |

static_cast<__launch_underlying_type>(__y));

}

inline _LIBCPP_INLINE_VISIBILITY

_LIBCPP_CONSTEXPR

launch

operator^(launch __x, launch __y)

{

return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^

static_cast<__launch_underlying_type>(__y));

}

inline _LIBCPP_INLINE_VISIBILITY

_LIBCPP_CONSTEXPR

launch

operator~(launch __x)

{

return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);

}

inline _LIBCPP_INLINE_VISIBILITY

launch&

operator&=(launch& __x, launch __y)

{

__x = __x & __y; return __x;

}

inline _LIBCPP_INLINE_VISIBILITY

launch&

operator|=(launch& __x, launch __y)

{

__x = __x | __y; return __x;

}

inline _LIBCPP_INLINE_VISIBILITY

launch&

operator^=(launch& __x, launch __y)

{

__x = __x ^ __y; return __x;

}

#endif // !_LIBCPP_HAS_NO_STRONG_ENUMS

//enum class future_status

_LIBCPP_DECLARE_STRONG_ENUM(future_status)

{

ready,

timeout,

deferred

};

_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)

_LIBCPP_FUNC_VIS

const error_category& future_category() _NOEXCEPT;

inline _LIBCPP_INLINE_VISIBILITY

error_code

make_error_code(future_errc __e) _NOEXCEPT

{

return error_code(static_cast<int>(__e), future_category());

}

inline _LIBCPP_INLINE_VISIBILITY

error_condition

make_error_condition(future_errc __e) _NOEXCEPT

{

return error_condition(static_cast<int>(__e), future_category());

}

class _LIBCPP_EXCEPTION_ABI future_error

: public logic_error

{

error_code __ec_;

public:

future_error(error_code __ec);

_LIBCPP_INLINE_VISIBILITY

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

virtual ~future_error() _NOEXCEPT;

};

class _LIBCPP_TYPE_VIS __assoc_sub_state

: public __shared_count

{

protected:

exception_ptr __exception_;

mutable mutex __mut_;

mutable condition_variable __cv_;

unsigned __state_;

virtual void __on_zero_shared() _NOEXCEPT;

void __sub_wait(unique_lock<mutex>& __lk);

public:

enum

{

__constructed = 1,

__future_attached = 2,

ready = 4,

deferred = 8

};

_LIBCPP_INLINE_VISIBILITY

__assoc_sub_state() : __state_(0) {}

_LIBCPP_INLINE_VISIBILITY

bool __has_value() const

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

_LIBCPP_INLINE_VISIBILITY

void __set_future_attached()

{

lock_guard<mutex> __lk(__mut_);

__state_ |= __future_attached;

}

_LIBCPP_INLINE_VISIBILITY

bool __has_future_attached() const {return (__state_ & __future_attached) != 0;}

_LIBCPP_INLINE_VISIBILITY

void __set_deferred() {__state_ |= deferred;}

void __make_ready();

_LIBCPP_INLINE_VISIBILITY

bool __is_ready() const {return (__state_ & ready) != 0;}

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::steady_clock::now() + __rel_time);

}

template <class _Rp>

class __assoc_state

: public __assoc_sub_state

{

typedef __assoc_sub_state base;

typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;

protected:

_Up __value_;

virtual void __on_zero_shared() _NOEXCEPT;

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

_Rp move();

typename add_lvalue_reference<_Rp>::type copy();

};

template <class _Rp>

void

__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT

{

if (this->__state_ & base::__constructed)

reinterpret_cast<_Rp*>(&__value_)->~_Rp();

delete this;

}

template <class _Rp>

template <class _Arg>

void

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

__assoc_state<_Rp>::set_value(_Arg&& __arg)

#else

__assoc_state<_Rp>::set_value(_Arg& __arg)

#endif

{

unique_lock<mutex> __lk(this->__mut_);

#ifndef _LIBCPP_NO_EXCEPTIONS

if (this->__has_value())

throw future_error(make_error_code(future_errc::promise_already_satisfied));

#endif

::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));

this->__state_ |= base::__constructed | base::ready;

__lk.unlock();

__cv_.notify_all();

}

template <class _Rp>

template <class _Arg>

void

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

__assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)

#else

__assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg)

#endif

{

unique_lock<mutex> __lk(this->__mut_);

#ifndef _LIBCPP_NO_EXCEPTIONS

if (this->__has_value())

throw future_error(make_error_code(future_errc::promise_already_satisfied));

#endif

::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));

this->__state_ |= base::__constructed;

__thread_local_data()->__make_ready_at_thread_exit(this);

__lk.unlock();

}

template <class _Rp>

_Rp

__assoc_state<_Rp>::move()

{

unique_lock<mutex> __lk(this->__mut_);

this->__sub_wait(__lk);

if (this->__exception_ != nullptr)

rethrow_exception(this->__exception_);

return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));

}

template <class _Rp>

typename add_lvalue_reference<_Rp>::type

__assoc_state<_Rp>::copy()

{

unique_lock<mutex> __lk(this->__mut_);

this->__sub_wait(__lk);

if (this->__exception_ != nullptr)

rethrow_exception(this->__exception_);

return *reinterpret_cast<_Rp*>(&__value_);

}

template <class _Rp>

class __assoc_state<_Rp&>

: public __assoc_sub_state

{

typedef __assoc_sub_state base;

typedef _Rp* _Up;

protected:

_Up __value_;

virtual void __on_zero_shared() _NOEXCEPT;

public:

void set_value(_Rp& __arg);

void set_value_at_thread_exit(_Rp& __arg);

_Rp& copy();

};

template <class _Rp>

void

__assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT

{

delete this;

}

template <class _Rp>

void

__assoc_state<_Rp&>::set_value(_Rp& __arg)

{

unique_lock<mutex> __lk(this->__mut_);

#ifndef _LIBCPP_NO_EXCEPTIONS

if (this->__has_value())

throw future_error(make_error_code(future_errc::promise_already_satisfied));

#endif

__value_ = _VSTD::addressof(__arg);

this->__state_ |= base::__constructed | base::ready;

__lk.unlock();

__cv_.notify_all();

}

template <class _Rp>

void

__assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)

{

unique_lock<mutex> __lk(this->__mut_);

#ifndef _LIBCPP_NO_EXCEPTIONS

if (this->__has_value())

throw future_error(make_error_code(future_errc::promise_already_satisfied));

#endif

__value_ = _VSTD::addressof(__arg);

this->__state_ |= base::__constructed;

__thread_local_data()->__make_ready_at_thread_exit(this);

__lk.unlock();

}

template <class _Rp>

_Rp&

__assoc_state<_Rp&>::copy()

{

unique_lock<mutex> __lk(this->__mut_);

this->__sub_wait(__lk);

if (this->__exception_ != nullptr)

rethrow_exception(this->__exception_);

return *__value_;

}

template <class _Rp, class _Alloc>

class __assoc_state_alloc

: public __assoc_state<_Rp>

{

typedef __assoc_state<_Rp> base;

_Alloc __alloc_;

virtual void __on_zero_shared() _NOEXCEPT;

public:

_LIBCPP_INLINE_VISIBILITY

explicit __assoc_state_alloc(const _Alloc& __a)

: __alloc_(__a) {}

};

template <class _Rp, class _Alloc>

void

__assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT

{

if (this->__state_ & base::__constructed)

reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp();

typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);

this->~__assoc_state_alloc();

__a.deallocate(this, 1);

}

template <class _Rp, class _Alloc>

class __assoc_state_alloc<_Rp&, _Alloc>

: public __assoc_state<_Rp&>

{

typedef __assoc_state<_Rp&> base;

_Alloc __alloc_;

virtual void __on_zero_shared() _NOEXCEPT;

public:

_LIBCPP_INLINE_VISIBILITY

explicit __assoc_state_alloc(const _Alloc& __a)

: __alloc_(__a) {}

};

template <class _Rp, class _Alloc>

void

__assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT

{

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() _NOEXCEPT;

public:

_LIBCPP_INLINE_VISIBILITY

explicit __assoc_sub_state_alloc(const _Alloc& __a)

: __alloc_(__a) {}

};

template <class _Alloc>

void

__assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT

{

typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_);

this->~__assoc_sub_state_alloc();

__a.deallocate(this, 1);

}

template <class _Rp, class _Fp>

class __deferred_assoc_state

: public __assoc_state<_Rp>

{

typedef __assoc_state<_Rp> base;

_Fp __func_;

public:

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

explicit __deferred_assoc_state(_Fp&& __f);

#endif

virtual void __execute();

};

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _Rp, class _Fp>

inline _LIBCPP_INLINE_VISIBILITY

__deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)

: __func_(_VSTD::forward<_Fp>(__f))

{

this->__set_deferred();

}

#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _Rp, class _Fp>

void

__deferred_assoc_state<_Rp, _Fp>::__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 _Fp>

class __deferred_assoc_state<void, _Fp>

: public __assoc_sub_state

{

typedef __assoc_sub_state base;

_Fp __func_;

public:

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

explicit __deferred_assoc_state(_Fp&& __f);

#endif

virtual void __execute();

};

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _Fp>

inline _LIBCPP_INLINE_VISIBILITY

__deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)

: __func_(_VSTD::forward<_Fp>(__f))

{

this->__set_deferred();

}

#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _Fp>

void

__deferred_assoc_state<void, _Fp>::__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 _Rp, class _Fp>

class __async_assoc_state

: public __assoc_state<_Rp>

{

typedef __assoc_state<_Rp> base;

_Fp __func_;

virtual void __on_zero_shared() _NOEXCEPT;

public:

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

explicit __async_assoc_state(_Fp&& __f);

#endif

virtual void __execute();

};

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _Rp, class _Fp>

inline _LIBCPP_INLINE_VISIBILITY

__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)

: __func_(_VSTD::forward<_Fp>(__f))

{

}

#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES

template <class _Rp, class _Fp>

void

__async_assoc_state<_Rp, _Fp>::__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 _Rp, class _Fp>

void

__async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT

{

this->wait();

base::__on_zero_shared();

}

template <class _Fp>

class __async_assoc_state<void, _Fp>

: public __assoc_sub_state

{

typedef __assoc_sub_state base;

_Fp __func_;

virtual void __on_zero_shared() _NOEXCEPT;

public:

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

explicit __async_assoc_state(_Fp&& __f);

#endif

virtual void __execute();

};