Kylin/Universal/Promise.h

327 lines
10 KiB
C
Raw Normal View History

2024-09-15 16:15:26 +08:00
#ifndef __PROMISE_H__
#define __PROMISE_H__
2024-09-15 23:39:23 +08:00
#include <exception>
class PromiseUndefinedException : public std::exception {
public:
};
class PromiseConversionException : public std::exception {
public:
};
2024-09-15 16:15:26 +08:00
#include "Private/PromiseHandler.h"
#include "Private/PromiseResolver.h"
#include <thread>
template <typename T>
class Promise;
template <typename T>
class PromiseBase {
friend struct PromiseFulfill<Promise<T>>;
public:
using Type = T;
template <typename F, typename std::enable_if<ArgsOf<F>::count == 1, int>::type = 0>
PromiseBase(F callback) : m_d{std::make_shared<PromiseData<T>>()} {
PromiseResolver<T> resolver{*this};
try {
callback(PromiseResolve<T>(resolver));
} catch (...) {
resolver.reject(std::current_exception());
}
}
template <typename F, typename std::enable_if<ArgsOf<F>::count != 1, int>::type = 0>
PromiseBase(F callback) : m_d{std::make_shared<PromiseData<T>>()} {
PromiseResolver<T> resolver{*this};
try {
callback(PromiseResolve<T>(resolver), PromiseReject<T>(resolver));
} catch (...) {
resolver.reject(std::current_exception());
}
}
PromiseBase(const PromiseBase<T> &other) : m_d{other.m_d} {
}
PromiseBase(const Promise<T> &other) : m_d{other.m_d} {
}
PromiseBase(PromiseBase<T> &&other) {
swap(other);
}
2024-09-15 23:39:23 +08:00
virtual ~PromiseBase() {
}
PromiseBase<T> &operator=(const PromiseBase<T> &other) {
m_d = other.m_d;
return *this;
}
PromiseBase<T> &operator=(PromiseBase<T> &&other) {
PromiseBase<T>(std::move(other)).swap(*this);
return *this;
}
bool operator==(const PromiseBase<T> &other) const {
return (m_d == other.m_d);
}
bool operator!=(const PromiseBase<T> &other) const {
return (m_d != other.m_d);
}
2024-09-15 16:15:26 +08:00
void swap(PromiseBase<T> &other) {
std::swap(m_d, other.m_d);
}
bool isFulfilled() const {
return m_d->isFulfilled();
}
bool isRejected() const {
return m_d->isRejected();
}
bool isPending() const {
return m_d->isPending();
}
template <typename TFulfilled, typename TRejected>
typename PromiseHandler<T, TFulfilled>::PromiseType then(const TFulfilled &fulfilled, const TRejected &rejected) const {
using PromiseType = typename PromiseHandler<T, TFulfilled>::PromiseType;
PromiseType next(
[&](const PromiseResolve<typename PromiseType::Type> &resolve, const PromiseReject<typename PromiseType::Type> &reject) {
m_d->addHandler(PromiseHandler<T, TFulfilled>::create(fulfilled, resolve, reject));
m_d->addCatcher(PromiseCatcher<T, TRejected>::create(rejected, resolve, reject));
});
if (!m_d->isPending()) {
m_d->dispatch();
}
return next;
}
template <typename TFulfilled>
typename PromiseHandler<T, TFulfilled>::PromiseType then(TFulfilled &&fulfilled) const {
return then(std::forward<TFulfilled>(fulfilled), nullptr);
}
2024-09-15 23:39:23 +08:00
template <typename THandler>
Promise<T> finally(THandler handler) const {
Promise<T> p = *this;
return p.then(handler, handler).then([=]() { return p; });
}
2024-09-15 16:15:26 +08:00
template <typename TRejected>
typename PromiseHandler<T, std::nullptr_t>::PromiseType fail(TRejected &&rejected) const {
return then(nullptr, std::forward<TRejected>(rejected));
}
Promise<T> wait() const {
while (m_d->isPending()) {
std::this_thread::yield();
}
return *this;
}
template <typename E>
static Promise<T> reject(E &&error) {
return Promise<T>{[&](const PromiseResolve<T> &, const PromiseReject<T> &reject) { reject(std::forward<E>(error)); }};
}
2024-09-15 23:39:23 +08:00
template <typename THandler>
Promise<T> tapFail(THandler handler) const {
Promise<T> p = *this;
return p.then([]() {}, handler).then([=]() { return p; });
}
template <typename THandler>
Promise<T> tap(THandler handler) const {
Promise<T> p = *this;
return p.then(handler).then([=]() { return p; });
}
#ifdef BOOST_ASIO_EXECUTION_EXECUTOR
template <class Executor, class Rep, class Period>
Promise<T> delay(Executor &ioContext, const std::chrono::duration<Rep, Period> &duration) const {
return tap([&]() {
return Promise<void>{[&](const PromiseResolve<void> &resolve) {
auto timer = std::make_shared<boost::asio::steady_timer>(ioContext, duration);
timer->async_wait([timer, resolve](const boost::system::error_code & /*e*/) mutable {
boost::asio::post(timer->get_executor(), resolve);
});
}};
});
}
template <class Executor>
Promise<T> delay(Executor &ioContext, int milliseconds) const {
return delay(ioContext, std::chrono::milliseconds(milliseconds));
}
#endif
2024-09-15 16:15:26 +08:00
protected:
std::shared_ptr<PromiseData<T>> m_d;
};
2024-09-15 23:39:23 +08:00
namespace PromiseHelper {
template <typename T>
typename PromiseDeduce<T>::Type resolve(T &&value) {
using PromiseType = typename PromiseDeduce<T>::Type;
using ValueType = typename PromiseType::Type;
using ResolveType = PromiseResolve<ValueType>;
using RejectType = PromiseReject<ValueType>;
return PromiseType{[&](ResolveType &&resolve, RejectType &&reject) {
PromiseFulfill<std::decay_t<T>>::call(std::forward<T>(value), std::forward<ResolveType>(resolve), std::forward<RejectType>(reject));
}};
}
Promise<void> resolve();
template <typename Functor, typename... Args>
typename PromiseFunctor<Functor, Args...>::PromiseType attempt(Functor &&fn, Args &&...args) {
using FunctorType = PromiseFunctor<Functor, Args...>;
using PromiseType = typename FunctorType::PromiseType;
using ValueType = typename PromiseType::Type;
// NOTE: std::forward<T<U>>: MSVC 2013 fails when forwarding
// template type (error: "expects 4 arguments - 0 provided").
// However it succeeds with type alias.
// TODO: should we expose QPromise::ResolveType & RejectType?
using ResolveType = PromiseResolve<ValueType>;
using RejectType = PromiseReject<ValueType>;
return PromiseType{[&](ResolveType &&resolve, RejectType &&reject) {
PromiseDispatch<typename FunctorType::ResultType>::call(std::forward<ResolveType>(resolve), std::forward<RejectType>(reject),
std::forward<Functor>(fn), std::forward<Args>(args)...);
}};
}
template <typename T, template <typename, typename...> class Sequence = std::vector, typename... Args>
Promise<std::vector<T>> all(const Sequence<Promise<T>, Args...> &promises) {
const int count = static_cast<int>(promises.size());
if (count == 0) {
return PromiseHelper::resolve(std::vector<T>{});
}
return Promise<std::vector<T>>{[=](const PromiseResolve<std::vector<T>> &resolve, const PromiseReject<std::vector<T>> &reject) {
auto remaining = std::make_shared<int>(count);
auto results = std::make_shared<std::vector<T>>(count);
int i = 0;
for (const auto &promise : promises) {
promise.then(
[=](const T &res) mutable {
(*results)[i] = res;
if (--(*remaining) == 0) {
resolve(*results);
}
},
[=]() mutable {
if (*remaining != -1) {
*remaining = -1;
reject(std::current_exception());
}
});
i++;
}
}};
}
template <template <typename, typename...> class Sequence = std::vector, typename... Args>
Promise<void> all(const Sequence<Promise<void>, Args...> &promises);
}; // namespace PromiseHelper
2024-09-15 16:15:26 +08:00
template <typename T>
class Promise : public PromiseBase<T> {
friend class PromiseResolver<T>;
public:
template <typename F>
Promise(F &&resolver) : PromiseBase<T>(std::forward<F>(resolver)) {
}
2024-09-15 23:39:23 +08:00
template <typename U>
Promise<U> convert() const {
return PromiseBase<T>::then(PromiseConverter<T, U>::create());
}
template <typename Functor>
Promise<T> each(Functor fn) {
return this->tap([=](const T &values) {
int i = 0;
std::vector<Promise<void>> promises;
for (const auto &v : values) {
promises.push_back(PromiseHelper::attempt(fn, v, i).then([]() {
// Cast to void in case fn returns a non promise value.
// TODO remove when implicit cast is implemented.
}));
i++;
}
return PromiseHelper::all(promises);
});
}
2024-09-15 16:15:26 +08:00
static Promise<T> resolve(const T &value) {
return Promise<T>{[&](const PromiseResolve<T> &resolve) { resolve(value); }};
}
};
template <>
class Promise<void> : public PromiseBase<void> {
friend class PromiseResolver<void>;
public:
template <typename F>
Promise(F &&resolver) : PromiseBase<void>(std::forward<F>(resolver)) {
}
public:
static Promise<void> resolve() {
return Promise<void>{[](const PromiseResolve<void> &resolve) { resolve(); }};
}
private:
friend class PromiseBase<void>;
};
2024-09-15 23:39:23 +08:00
namespace PromiseHelper {
Promise<void> resolve() {
return Promise<void>{[](const PromiseResolve<void> &resolve) { resolve(); }};
}
2024-10-29 21:51:37 +08:00
template <template <typename, typename...> class Sequence, typename... Args>
2024-09-15 23:39:23 +08:00
Promise<void> all(const Sequence<Promise<void>, Args...> &promises) {
const int count = static_cast<int>(promises.size());
if (count == 0) {
return PromiseHelper::resolve();
}
return Promise<void>{[=](const PromiseResolve<void> &resolve, const PromiseReject<void> &reject) {
auto remaining = std::make_shared<int>(count);
for (const auto &promise : promises) {
promise.then(
[=]() {
if (--(*remaining) == 0) {
resolve();
}
},
[=]() {
if (*remaining != -1) {
*remaining = -1;
reject(std::current_exception());
}
});
}
}};
}
} // namespace PromiseHelper
2024-09-15 16:15:26 +08:00
#endif // __PROMISE_H__