| //===------------------------- future.cpp ---------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "__config" |
| |
| #ifndef _LIBCPP_HAS_NO_THREADS |
| |
| #include "future" |
| #include "string" |
| |
| _LIBCPP_BEGIN_NAMESPACE_STD |
| |
| class _LIBCPP_HIDDEN __future_error_category |
| : public __do_message |
| { |
| public: |
| virtual const char* name() const noexcept; |
| virtual string message(int ev) const; |
| }; |
| |
| const char* |
| __future_error_category::name() const noexcept |
| { |
| return "future"; |
| } |
| |
| #if defined(__clang__) |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wswitch" |
| #elif defined(__GNUC__) || defined(__GNUG__) |
| #pragma GCC diagnostic push |
| #pragma GCC diagnostic ignored "-Wswitch" |
| #endif |
| |
| string |
| __future_error_category::message(int ev) const |
| { |
| switch (static_cast<future_errc>(ev)) |
| { |
| case future_errc(0): // For backwards compatibility with C++11 (LWG 2056) |
| case future_errc::broken_promise: |
| return string("The associated promise has been destructed prior " |
| "to the associated state becoming ready."); |
| case future_errc::future_already_retrieved: |
| return string("The future has already been retrieved from " |
| "the promise or packaged_task."); |
| case future_errc::promise_already_satisfied: |
| return string("The state of the promise has already been set."); |
| case future_errc::no_state: |
| return string("Operation not permitted on an object without " |
| "an associated state."); |
| } |
| return string("unspecified future_errc value\n"); |
| } |
| |
| #if defined(__clang__) |
| #pragma clang diagnostic pop |
| #elif defined(__GNUC__) || defined(__GNUG__) |
| #pragma GCC diagnostic pop |
| #endif |
| |
| const error_category& |
| future_category() noexcept |
| { |
| static __future_error_category __f; |
| return __f; |
| } |
| |
| future_error::future_error(error_code __ec) |
| : logic_error(__ec.message()), |
| __ec_(__ec) |
| { |
| } |
| |
| future_error::~future_error() noexcept |
| { |
| } |
| |
| void |
| __assoc_sub_state::__on_zero_shared() noexcept |
| { |
| delete this; |
| } |
| |
| void |
| __assoc_sub_state::set_value() |
| { |
| unique_lock<mutex> __lk(__mut_); |
| if (__has_value()) |
| __throw_future_error(future_errc::promise_already_satisfied); |
| __state_ |= __constructed | ready; |
| __cv_.notify_all(); |
| } |
| |
| void |
| __assoc_sub_state::set_value_at_thread_exit() |
| { |
| unique_lock<mutex> __lk(__mut_); |
| if (__has_value()) |
| __throw_future_error(future_errc::promise_already_satisfied); |
| __state_ |= __constructed; |
| __thread_local_data()->__make_ready_at_thread_exit(this); |
| } |
| |
| void |
| __assoc_sub_state::set_exception(exception_ptr __p) |
| { |
| unique_lock<mutex> __lk(__mut_); |
| if (__has_value()) |
| __throw_future_error(future_errc::promise_already_satisfied); |
| __exception_ = __p; |
| __state_ |= ready; |
| __cv_.notify_all(); |
| } |
| |
| void |
| __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p) |
| { |
| unique_lock<mutex> __lk(__mut_); |
| if (__has_value()) |
| __throw_future_error(future_errc::promise_already_satisfied); |
| __exception_ = __p; |
| __thread_local_data()->__make_ready_at_thread_exit(this); |
| } |
| |
| void |
| __assoc_sub_state::__make_ready() |
| { |
| unique_lock<mutex> __lk(__mut_); |
| __state_ |= ready; |
| __cv_.notify_all(); |
| } |
| |
| void |
| __assoc_sub_state::copy() |
| { |
| unique_lock<mutex> __lk(__mut_); |
| __sub_wait(__lk); |
| if (__exception_ != nullptr) |
| rethrow_exception(__exception_); |
| } |
| |
| void |
| __assoc_sub_state::wait() |
| { |
| unique_lock<mutex> __lk(__mut_); |
| __sub_wait(__lk); |
| } |
| |
| void |
| __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk) |
| { |
| if (!__is_ready()) |
| { |
| if (__state_ & static_cast<unsigned>(deferred)) |
| { |
| __state_ &= ~static_cast<unsigned>(deferred); |
| __lk.unlock(); |
| __execute(); |
| } |
| else |
| while (!__is_ready()) |
| __cv_.wait(__lk); |
| } |
| } |
| |
| void |
| __assoc_sub_state::__execute() |
| { |
| __throw_future_error(future_errc::no_state); |
| } |
| |
| future<void>::future(__assoc_sub_state* __state) |
| : __state_(__state) |
| { |
| __state_->__attach_future(); |
| } |
| |
| future<void>::~future() |
| { |
| if (__state_) |
| __state_->__release_shared(); |
| } |
| |
| void |
| future<void>::get() |
| { |
| unique_ptr<__shared_count, __release_shared_count> __(__state_); |
| __assoc_sub_state* __s = __state_; |
| __state_ = nullptr; |
| __s->copy(); |
| } |
| |
| promise<void>::promise() |
| : __state_(new __assoc_sub_state) |
| { |
| } |
| |
| promise<void>::~promise() |
| { |
| if (__state_) |
| { |
| #ifndef _LIBCPP_NO_EXCEPTIONS |
| if (!__state_->__has_value() && __state_->use_count() > 1) |
| __state_->set_exception(make_exception_ptr( |
| future_error(make_error_code(future_errc::broken_promise)) |
| )); |
| #endif // _LIBCPP_NO_EXCEPTIONS |
| __state_->__release_shared(); |
| } |
| } |
| |
| future<void> |
| promise<void>::get_future() |
| { |
| if (__state_ == nullptr) |
| __throw_future_error(future_errc::no_state); |
| return future<void>(__state_); |
| } |
| |
| void |
| promise<void>::set_value() |
| { |
| if (__state_ == nullptr) |
| __throw_future_error(future_errc::no_state); |
| __state_->set_value(); |
| } |
| |
| void |
| promise<void>::set_exception(exception_ptr __p) |
| { |
| if (__state_ == nullptr) |
| __throw_future_error(future_errc::no_state); |
| __state_->set_exception(__p); |
| } |
| |
| void |
| promise<void>::set_value_at_thread_exit() |
| { |
| if (__state_ == nullptr) |
| __throw_future_error(future_errc::no_state); |
| __state_->set_value_at_thread_exit(); |
| } |
| |
| void |
| promise<void>::set_exception_at_thread_exit(exception_ptr __p) |
| { |
| if (__state_ == nullptr) |
| __throw_future_error(future_errc::no_state); |
| __state_->set_exception_at_thread_exit(__p); |
| } |
| |
| shared_future<void>::~shared_future() |
| { |
| if (__state_) |
| __state_->__release_shared(); |
| } |
| |
| shared_future<void>& |
| shared_future<void>::operator=(const shared_future& __rhs) |
| { |
| if (__rhs.__state_) |
| __rhs.__state_->__add_shared(); |
| if (__state_) |
| __state_->__release_shared(); |
| __state_ = __rhs.__state_; |
| return *this; |
| } |
| |
| _LIBCPP_END_NAMESPACE_STD |
| |
| #endif // !_LIBCPP_HAS_NO_THREADS |