import RT-Thread@9217865c without bsp, libcpu and components/net
This commit is contained in:
Zihao Yu
commit
e2376a3709
1414 changed files with 390370 additions and 0 deletions
336
components/libc/cplusplus/cpp11/gcc/future
Normal file
336
components/libc/cplusplus/cpp11/gcc/future
Normal file
|
|
@ -0,0 +1,336 @@
|
|||
#pragma once
|
||||
|
||||
#if __cplusplus < 201103L
|
||||
#error "C++ version lower than C++11"
|
||||
#endif
|
||||
|
||||
#include <mutex>
|
||||
#include <condition_variable>
|
||||
#include <memory>
|
||||
#include <chrono>
|
||||
#include <cassert>
|
||||
|
||||
namespace std {
|
||||
|
||||
enum class future_status {
|
||||
ready,
|
||||
timeout,
|
||||
deferred
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
|
||||
class shared_state_base {
|
||||
protected:
|
||||
typedef void (*deleter_fn)(void *v);
|
||||
|
||||
using scoped_lock = std::lock_guard<std::mutex>;
|
||||
using unique_lock = std::unique_lock<std::mutex>;
|
||||
public:
|
||||
explicit shared_state_base(deleter_fn d) : v_(nullptr), d_(d), valid_(true) {}
|
||||
|
||||
~shared_state_base() { d_(v_); }
|
||||
|
||||
shared_state_base(shared_state_base &&other) = delete;
|
||||
|
||||
shared_state_base(const shared_state_base &other) = delete;
|
||||
|
||||
shared_state_base &operator=(shared_state_base &&other) = delete;
|
||||
|
||||
shared_state_base &operator=(const shared_state_base &other) = delete;
|
||||
|
||||
void wait() {
|
||||
unique_lock lock(m_);
|
||||
c_.wait(lock, [this] { return has_value(); });
|
||||
}
|
||||
|
||||
template <class Rep, class Period>
|
||||
std::future_status
|
||||
wait_for(const std::chrono::duration<Rep, Period> &rel_time) {
|
||||
unique_lock lock(m_);
|
||||
if (c_.wait_for(lock, rel_time, [this] { return has_value(); })) {
|
||||
return std::future_status::ready;
|
||||
}
|
||||
return std::future_status::timeout;
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
std::future_status
|
||||
wait_until(const std::chrono::time_point<Clock, Duration> &abs_time) {
|
||||
unique_lock lock(m_);
|
||||
if (c_.wait_until(lock, abs_time, [this] { return has_value(); })) {
|
||||
return std::future_status::ready;
|
||||
}
|
||||
return std::future_status::timeout;
|
||||
}
|
||||
|
||||
protected:
|
||||
bool has_value() { return v_ != nullptr; }
|
||||
|
||||
protected:
|
||||
std::mutex m_;
|
||||
std::condition_variable c_;
|
||||
void *v_;
|
||||
deleter_fn d_;
|
||||
bool valid_;
|
||||
};
|
||||
|
||||
|
||||
template <typename R>
|
||||
class shared_state: public shared_state_base {
|
||||
public:
|
||||
shared_state() :shared_state_base(default_deleter_) {}
|
||||
|
||||
~shared_state() {}
|
||||
|
||||
R &get() {
|
||||
wait();
|
||||
scoped_lock lock(m_);
|
||||
assert(valid_);
|
||||
valid_ = false;
|
||||
return *(static_cast<R *>(v_));
|
||||
}
|
||||
|
||||
void set(const R &v) {
|
||||
scoped_lock lock(m_);
|
||||
assert(!has_value());
|
||||
v_ = new R(v);
|
||||
valid_ = true;
|
||||
c_.notify_one();
|
||||
}
|
||||
|
||||
void set(R &&v) {
|
||||
scoped_lock lock(m_);
|
||||
assert(!has_value());
|
||||
v_ = new R(std::move(v));
|
||||
valid_ = true;
|
||||
c_.notify_one();
|
||||
}
|
||||
|
||||
bool valid() {
|
||||
scoped_lock lock(m_);
|
||||
return valid_;
|
||||
}
|
||||
|
||||
private:
|
||||
static void default_deleter_(void *v) { delete static_cast<R *>(v); }
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename R>
|
||||
class shared_future {
|
||||
};
|
||||
|
||||
|
||||
template <typename R>
|
||||
class future {
|
||||
using state_type = std::shared_ptr<detail::shared_state<R>>;
|
||||
public:
|
||||
future() {}
|
||||
|
||||
explicit future(const state_type &state) : state_(state) {}
|
||||
|
||||
future(future &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
future(const future &other) = delete;
|
||||
|
||||
~future() {}
|
||||
|
||||
future &operator=(future &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
future &operator=(const future &other) = delete;
|
||||
|
||||
void swap(future &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::shared_future<R> share() noexcept { return std::shared_future<R>(); }
|
||||
|
||||
R get() { return state_->get(); }
|
||||
|
||||
bool valid() const noexcept { return state_->valid(); }
|
||||
|
||||
void wait() const { state_->wait(); }
|
||||
|
||||
template <class Rep, class Period>
|
||||
std::future_status
|
||||
wait_for(const std::chrono::duration<Rep, Period> &rel_time) const {
|
||||
return state_->wait_for(rel_time);
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
std::future_status
|
||||
wait_until(const std::chrono::time_point<Clock, Duration> &abs_time) const {
|
||||
return state_->wait_until(abs_time);
|
||||
}
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
class future<void> {
|
||||
using state_type = std::shared_ptr<detail::shared_state<int>>;
|
||||
public:
|
||||
future() {}
|
||||
|
||||
explicit future(const state_type &state) : state_(state) {}
|
||||
|
||||
future(future &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
future(const future &other) = delete;
|
||||
|
||||
~future() {}
|
||||
|
||||
future &operator=(future &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
future &operator=(const future &other) = delete;
|
||||
|
||||
void swap(future &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::shared_future<void> share() noexcept { return std::shared_future<void>(); }
|
||||
|
||||
void get() { state_->get(); }
|
||||
|
||||
bool valid() const noexcept { return state_->valid(); }
|
||||
|
||||
void wait() const { state_->wait(); }
|
||||
|
||||
template <class Rep, class Period>
|
||||
std::future_status
|
||||
wait_for(const std::chrono::duration<Rep, Period> &rel_time) const {
|
||||
return state_->wait_for(rel_time);
|
||||
}
|
||||
|
||||
template <class Clock, class Duration>
|
||||
std::future_status
|
||||
wait_until(const std::chrono::time_point<Clock, Duration> &abs_time) const {
|
||||
return state_->wait_until(abs_time);
|
||||
}
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <typename R>
|
||||
class promise {
|
||||
using state_type = std::shared_ptr<detail::shared_state<R>>;
|
||||
public:
|
||||
promise() : state_(new detail::shared_state<R>()) {}
|
||||
|
||||
promise(promise &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
promise(const promise &other) = delete;
|
||||
|
||||
~promise() {}
|
||||
|
||||
promise &operator=(promise &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
promise &operator=(const promise &other) = delete;
|
||||
|
||||
void swap(promise &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::future<R> get_future() { return std::future<R>(state_); }
|
||||
|
||||
void set_value(const R &value) { state_->set(value); }
|
||||
|
||||
void set_value(R &&value) { state_->set(std::move(value)); }
|
||||
|
||||
void set_value_at_thread_exit(const R &value);
|
||||
|
||||
void set_value_at_thread_exit(R &&value);
|
||||
|
||||
void set_exception(std::exception_ptr p);
|
||||
|
||||
void set_exception_at_thread_exit(std::exception_ptr p);
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <>
|
||||
class promise<void> {
|
||||
using state_type = std::shared_ptr<detail::shared_state<int>>;
|
||||
public:
|
||||
promise() : state_(new detail::shared_state<int>()) {}
|
||||
|
||||
promise(promise &&other) noexcept: state_(std::move(other.state_)) {
|
||||
other.state_.reset();
|
||||
}
|
||||
|
||||
promise(const promise &other) = delete;
|
||||
|
||||
~promise() {}
|
||||
|
||||
promise &operator=(promise &&other) noexcept {
|
||||
if (&other != this) {
|
||||
state_ = std::move(other.state_);
|
||||
other.state_.reset();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
promise &operator=(const promise &other) = delete;
|
||||
|
||||
void swap(promise &other) noexcept {
|
||||
std::swap(state_, other.state_);
|
||||
}
|
||||
|
||||
std::future<void> get_future() { return std::future<void>(state_); }
|
||||
|
||||
void set_value() { state_->set(0); }
|
||||
|
||||
void set_value_at_thread_exit();
|
||||
|
||||
void set_exception(std::exception_ptr p);
|
||||
|
||||
void set_exception_at_thread_exit(std::exception_ptr p);
|
||||
|
||||
private:
|
||||
state_type state_;
|
||||
};
|
||||
|
||||
|
||||
template <class R>
|
||||
void swap(std::future<R> &lhs, std::future<R> &rhs) noexcept {
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
template <class R>
|
||||
void swap(std::promise<R> &lhs, std::promise<R> &rhs) noexcept {
|
||||
lhs.swap(rhs);
|
||||
}
|
||||
|
||||
} // namespace std
|
||||
Loading…
Add table
Add a link
Reference in a new issue