async.h

#ifndef ORIGINAL_ASYNC_H
#define ORIGINAL_ASYNC_H
 
#include "atomic.h"
#include "condition.h"
#include "optional.h"
#include "refCntPtr.h"
#include "thread.h"
#include <exception>
#include <functional>
#include <utility>
 
namespace original {
 
    class async {
        // ==================== Async Wrapper (Internal) ====================
 
        template<typename TYPE>
        class asyncWrapper {
            atomic<bool> ready_{makeAtomic(false)};  
            strongPtr<TYPE> result_;                      
            mutable pCondition cond_{};                   
            mutable pMutex mutex_{};                      
            std::exception_ptr e_{};                      
 
        public:
            asyncWrapper();
 
            void setValue(TYPE&& v);
 
            void setException(std::exception_ptr e);
 
            [[nodiscard]] bool ready() const;
 
            void wait() const;
 
            bool waitFor(time::duration timeout) const;
 
            TYPE get();
 
            const TYPE& peek() const;
 
            strongPtr<TYPE> getPtr() const;
 
            void rethrowIfException() const;
 
            [[nodiscard]] std::exception_ptr exception() const;
        };
 
    public:
        class futureBase {
        public:
            [[nodiscard]] virtual bool valid() const noexcept = 0;
 
            virtual void wait() const = 0;
 
            virtual bool waitFor(time::duration timeout) const = 0;
 
            [[nodiscard]] virtual std::exception_ptr exception() const noexcept = 0;
 
            [[nodiscard]] virtual bool ready() const = 0;
 
            virtual ~futureBase() = default;
        };
 
        // ==================== Future Class ====================
 
        template<typename TYPE>
        class sharedFuture;
 
        template<typename TYPE>
        class future final : public futureBase {
            strongPtr<asyncWrapper<TYPE>> awr_{};  
 
            friend class async;
            explicit future(strongPtr<asyncWrapper<TYPE>> awr);
 
        public:
            future() = default;
 
            // Disable copying
            future(const future&) = delete;
            future& operator=(const future&) = delete;
 
            // Allow moving
            future(future&&) = default;
            future& operator=(future&&) = default;
 
            [[nodiscard]] bool valid() const noexcept override;
 
            sharedFuture<TYPE> share();
 
            TYPE result();
 
            [[nodiscard]] bool ready() const override;
 
            [[nodiscard]] std::exception_ptr exception() const noexcept override;
 
            void wait() const override;
 
            bool waitFor(time::duration timeout) const override;
        };
 
        template<typename TYPE>
        class sharedFuture final : public futureBase, public hashable<sharedFuture<TYPE>> {
            strongPtr<asyncWrapper<TYPE>> awr_{};
 
            friend class async;
            explicit sharedFuture(strongPtr<asyncWrapper<TYPE>> awr);
 
        public:
            sharedFuture() = default;
 
            // Allow copying and moving
            sharedFuture(const sharedFuture&) = default;
            sharedFuture& operator=(const sharedFuture&) = default;
            sharedFuture(sharedFuture&&) = default;
            sharedFuture& operator=(sharedFuture&&) = default;
 
            [[nodiscard]] bool valid() const noexcept override;
 
            TYPE result() const;
 
            strongPtr<const TYPE> strongPointer() const;
 
            [[nodiscard]] bool ready() const override;
 
            [[nodiscard]] std::exception_ptr exception() const noexcept override;
 
            bool operator==(const sharedFuture& other) const noexcept;
 
            bool operator!=(const sharedFuture& other) const noexcept;
 
            void wait() const override;
 
            bool waitFor(time::duration timeout) const override;
 
            [[nodiscard]] u_integer toHash() const noexcept override;
 
            bool equals(const sharedFuture& other) const noexcept override;
 
            ~sharedFuture() override = default;
        };
 
        // ==================== Promise Class ====================
 
        template<typename TYPE, typename Callback>
        class promise {
            std::function<TYPE()> c_{};                
            strongPtr<asyncWrapper<TYPE>> awr_{};      
            bool valid_{false};                         
 
        public:
            // Disable copying to prevent multiple executions of the same computation
            promise(const promise&) = delete;
            promise& operator=(const promise&) = delete;
 
            // Allow moving to transfer ownership of the computation
            promise(promise&& other) noexcept;
 
            promise& operator=(promise&& other) noexcept;
 
            promise() = default;
 
            explicit promise(Callback&& c);
 
            future<TYPE> getFuture();
 
            [[nodiscard]] bool valid() const noexcept;
 
            std::function<TYPE()> function();
 
            void run();
        };
 
        // ==================== Static Factory Methods ====================
 
        template <typename Callback, typename... Args>
        static auto makePromise(Callback&& c, Args&&... args);
 
        template <typename Callback, typename... Args>
        static auto get(Callback&& c, Args&&... args) -> future<std::invoke_result_t<std::decay_t<Callback>, std::decay_t<Args>...>>;
    };
 
    template<typename T, typename Callback>
    auto operator|(async::future<T> f, Callback&& c);
 
    template <typename Callback>
    auto operator|(async::future<void> f, Callback&& c);
 
    template<typename T, typename Callback>
    auto operator|(async::sharedFuture<T> sf, Callback&& c);
 
    template <typename Callback>
    auto operator|(async::sharedFuture<void> sf, Callback&& c);
 
    template<typename T, typename Callback1, typename Callback2>
    auto operator|(async::promise<T, Callback1> p, Callback2&& c);
 
    template<typename Callback1, typename Callback2>
    auto operator|(async::promise<void, Callback1> p, Callback2&& c);
 
 
    // ==================== Void Specializations ====================
 
    template <>
    class async::asyncWrapper<void> {
        atomic<bool> ready_{makeAtomic(false)};  
        alternative<void> result_;                    
        mutable pCondition cond_{};                   
        mutable pMutex mutex_{};                      
        std::exception_ptr e_{};                      
 
    public:
        asyncWrapper() = default;
 
        void setValue();
 
        void setException(std::exception_ptr e);
 
        [[nodiscard]] bool ready() const;
 
        void wait() const;
 
        bool waitFor(time::duration timeout) const;
 
        void get();
 
        void peek() const;
 
        void rethrowIfException() const;
 
        [[nodiscard]] std::exception_ptr exception() const noexcept;
    };
 
    template <>
    class async::future<void> final : public futureBase {
        strongPtr<asyncWrapper<void>> awr_{};  
 
        friend class async;
        explicit future(strongPtr<asyncWrapper<void>> awr);
 
    public:
        future() = default;
 
        // Disable copying
        future(const future&) = delete;
        future& operator=(const future&) = delete;
 
        // Allow moving
        future(future&&) = default;
        future& operator=(future&&) = default;
 
        [[nodiscard]] bool valid() const noexcept override;
 
        sharedFuture<void> share();
 
        void result();
 
        [[nodiscard]] bool ready() const override;
 
        [[nodiscard]] std::exception_ptr exception() const noexcept override;
 
        void wait() const override;
 
        bool waitFor(time::duration timeout) const override;
    };
 
    template <>
    class async::sharedFuture<void> final : public futureBase, public hashable<sharedFuture<void>> {
        strongPtr<asyncWrapper<void>> awr_{};
 
        friend class async;
        explicit sharedFuture(strongPtr<asyncWrapper<void>> awr);
 
    public:
        sharedFuture() = default;
 
        // Allow copying and moving
        sharedFuture(const sharedFuture&) = default;
        sharedFuture& operator=(const sharedFuture&) = default;
        sharedFuture(sharedFuture&&) = default;
        sharedFuture& operator=(sharedFuture&&) = default;
 
        [[nodiscard]] bool valid() const noexcept override;
 
        void result() const;
 
        [[nodiscard]] bool ready() const override;
 
        [[nodiscard]] std::exception_ptr exception() const noexcept override;
 
        bool operator==(const sharedFuture& other) const noexcept;
 
        bool operator!=(const sharedFuture& other) const noexcept;
 
        void wait() const override;
 
        bool waitFor(time::duration timeout) const override;
 
        [[nodiscard]] u_integer toHash() const noexcept override;
 
        [[nodiscard]] bool equals(const sharedFuture& other) const noexcept override;
 
        ~sharedFuture() override = default;
    };
 
    template <typename Callback>
    class async::promise<void, Callback> {
        std::function<void()> c_{};                  
        strongPtr<asyncWrapper<void>> awr_{};        
        bool valid_{false};                           
 
    public:
        // Disable copying to prevent multiple executions of the same computation
        promise(const promise&) = delete;
        promise& operator=(const promise&) = delete;
 
        // Allow moving to transfer ownership of the computation
        promise(promise&& other) noexcept;
 
        promise& operator=(promise&& other) noexcept;
 
        promise() = default;
 
        explicit promise(Callback&& c);
 
        [[nodiscard]] future<void> getFuture() const;
 
        [[nodiscard]] bool valid() const noexcept;
 
        std::function<void()> function();
 
        void run();
    };
} // namespace original
 
template <typename TYPE>
original::async::asyncWrapper<TYPE>::asyncWrapper() = default;
 
template <typename TYPE>
void original::async::asyncWrapper<TYPE>::setValue(TYPE&& v)
{
    {
        uniqueLock lock{this->mutex_};
        this->result_ = makeStrongPtr<TYPE>(std::move(v));
        this->ready_.store(true);
    }
    this->cond_.notify();
}
 
template <typename TYPE>
void original::async::asyncWrapper<TYPE>::setException(std::exception_ptr e)
{
    {
        uniqueLock lock{this->mutex_};
        this->e_ = std::move(e);
        this->ready_.store(true);
    }
    this->cond_.notify();
}
 
template <typename TYPE>
bool original::async::asyncWrapper<TYPE>::ready() const
{
    return this->ready_.load();
}
 
template <typename TYPE>
void original::async::asyncWrapper<TYPE>::wait() const
{
    uniqueLock lock{this->mutex_};
    this->cond_.wait(this->mutex_, [this]
    {
        return this->ready();
    });
}
 
template <typename TYPE>
bool original::async::asyncWrapper<TYPE>::waitFor(time::duration timeout) const
{
    uniqueLock lock{this->mutex_};
    return this->cond_.waitFor(this->mutex_, timeout, [this]
    {
        return this->ready();
    });
}
 
template <typename TYPE>
TYPE original::async::asyncWrapper<TYPE>::get()
{
    uniqueLock lock{this->mutex_};
    this->rethrowIfException();
    if (this->result_) {
        TYPE result = std::move(*this->result_);
        this->result_.reset();
        return result;
    }
    this->cond_.wait(this->mutex_, [this]{
        return this->ready();
    });
 
    this->rethrowIfException();
 
    TYPE result = std::move(*this->result_);
    this->result_.reset();
    return result;
}
 
template <typename TYPE>
const TYPE& original::async::asyncWrapper<TYPE>::peek() const
{
    uniqueLock lock{this->mutex_};
    this->rethrowIfException();
    if (this->result_) {
        return *this->result_;
    }
    this->cond_.wait(this->mutex_, [this]{
        return this->ready();
    });
 
    this->rethrowIfException();
    return *this->result_;
}
 
template <typename TYPE>
original::strongPtr<TYPE> original::async::asyncWrapper<TYPE>::getPtr() const
{
    this->rethrowIfException();
    return this->result_;
}
 
template <typename TYPE>
void original::async::asyncWrapper<TYPE>::rethrowIfException() const
{
    if (this->e_)
        std::rethrow_exception(this->e_);
}
 
template <typename TYPE>
std::exception_ptr
original::async::asyncWrapper<TYPE>::exception() const
{
    uniqueLock lock{this->mutex_};
    return this->e_;
}
 
template <typename TYPE>
original::async::future<TYPE>::future(strongPtr<asyncWrapper<TYPE>> awr)
    : awr_(std::move(awr)) {}
 
template <typename TYPE>
bool original::async::future<TYPE>::valid() const noexcept
{
    return this->awr_ != nullptr;
}
 
template <typename TYPE>
original::async::sharedFuture<TYPE> original::async::future<TYPE>::share()
{
    return sharedFuture<TYPE>(std::move(this->awr_));
}
 
 
template <typename TYPE>
TYPE original::async::future<TYPE>::result()
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    return this->awr_->get();
}
 
template <typename TYPE>
bool original::async::future<TYPE>::ready() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    return this->awr_->ready();
}
 
template <typename TYPE>
std::exception_ptr original::async::future<TYPE>::exception() const noexcept
{
    if (!this->valid()) {
        return {};
    }
    return this->awr_->exception();
}
 
template <typename TYPE>
void original::async::future<TYPE>::wait() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    this->awr_->wait();
}
 
template <typename TYPE>
bool original::async::future<TYPE>::waitFor(time::duration timeout) const
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    return this->awr_->waitFor(timeout);
}
 
template <typename TYPE>
original::async::sharedFuture<TYPE>::sharedFuture(strongPtr<asyncWrapper<TYPE>> awr)
    : awr_(std::move(awr)) {}
 
template <typename TYPE>
bool original::async::sharedFuture<TYPE>::valid() const noexcept
{
    return this->awr_ != nullptr;
}
 
template <typename TYPE>
TYPE original::async::sharedFuture<TYPE>::result() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    return this->awr_->peek();
}
 
template <typename TYPE>
original::strongPtr<const TYPE> original::async::sharedFuture<TYPE>::strongPointer() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    if (!this->ready()) {
        throw sysError("Cannot get a strongPtr from a sharedFuture that is not ready");
    }
    return this->awr_->getPtr().template constCastTo<const TYPE>();
}
 
template <typename TYPE>
bool original::async::sharedFuture<TYPE>::ready() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    return this->awr_->ready();
}
 
template <typename TYPE>
std::exception_ptr original::async::sharedFuture<TYPE>::exception() const noexcept
{
    if (!this->valid()) {
        return {};
    }
    return this->awr_->exception();
}
 
template <typename TYPE>
bool original::async::sharedFuture<TYPE>::operator==(const sharedFuture& other) const noexcept
{
    return this->awr_ == other.awr_;
}
 
template <typename TYPE>
bool original::async::sharedFuture<TYPE>::operator!=(const sharedFuture& other) const noexcept
{
    return this->awr_ != other.awr_;
}
 
template <typename TYPE>
void original::async::sharedFuture<TYPE>::wait() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    this->awr_->wait();
}
 
template <typename TYPE>
bool original::async::sharedFuture<TYPE>::waitFor(time::duration timeout) const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    return this->awr_->waitFor(timeout);
}
 
template <typename TYPE>
original::u_integer original::async::sharedFuture<TYPE>::toHash() const noexcept
{
    return this->awr_.toHash();
}
 
template <typename TYPE>
bool original::async::sharedFuture<TYPE>::equals(const sharedFuture& other) const noexcept
{
    return *this == other;
}
 
template <typename TYPE, typename Callback>
original::async::promise<TYPE, Callback>::promise(promise&& other) noexcept
{
    if (!other.valid()){
        return;
    }
    this->valid_ = true;
    this->c_ = std::move(other.c_);
    this->awr_ = std::move(other.awr_);
    other.valid_ = false;
}
 
template <typename TYPE, typename Callback>
original::async::promise<TYPE, Callback>&
original::async::promise<TYPE, Callback>::operator=(promise&& other) noexcept
{
    if (this == &other || !other.valid()) {
        return *this;
    }
    this->valid_ = true;
    this->c_ = std::move(other.c_);
    this->awr_ = std::move(other.awr_);
    other.valid_ = false;
    return *this;
}
 
template <typename TYPE, typename Callback>
original::async::promise<TYPE, Callback>::promise(Callback&& c)
    : c_(std::forward<Callback>(c)), awr_(makeStrongPtr<asyncWrapper<TYPE>>()), valid_(true) {}
 
template <typename TYPE, typename Callback>
original::async::future<TYPE>
original::async::promise<TYPE, Callback>::getFuture()
{
    return future<TYPE>(this->awr_);
}
 
template <typename TYPE, typename Callback>
bool original::async::promise<TYPE, Callback>::valid() const noexcept
{
    return this->valid_;
}
 
template <typename TYPE, typename Callback>
std::function<TYPE()> original::async::promise<TYPE, Callback>::function()
{
    if (!this->valid_) {
        throw sysError("Try to get an invalid task");
    }
    this->valid_ = false;
    return std::move(this->c_);
}
 
template <typename TYPE, typename Callback>
void original::async::promise<TYPE, Callback>::run()
{
    if (!this->valid_) {
        throw sysError("Try to run an invalid task");
    }
    try {
        this->awr_->setValue(this->c_());
    } catch (...) {
        this->awr_->setException(std::current_exception());
    }
    this->valid_ = false;
}
 
template <typename Callback, typename... Args>
auto original::async::makePromise(Callback&& c, Args&&... args) {
    using Return = std::invoke_result_t<Callback, Args...>;
    auto bound = [c = std::forward<Callback>(c),
                  ... args = std::forward<Args>(args)]() mutable -> Return {
        return c(args...);
    };
 
    return promise<Return, decltype(bound)>{std::move(bound)};
}
 
template <typename Callback, typename ... Args>
auto original::async::get(Callback&& c, Args&&... args)
    -> future<std::invoke_result_t<std::decay_t<Callback>, std::decay_t<Args>...>>
{
    auto p = makePromise(std::forward<Callback>(c), std::forward<Args>(args)...);
    auto fut = p.getFuture();
 
    auto p_shared = makeStrongPtr<decltype(p)>(std::move(p));
    thread t{
        [p_shared]() mutable {
            p_shared->run();
        },
        thread::AUTO_DETACH
    };
 
    return fut;
}
 
template <typename T, typename Callback>
auto original::operator|(async::future<T> f, Callback&& c)
{
    using ResultType = std::invoke_result_t<Callback, T>;
    strongPtr<async::future<T>> shared_f = makeStrongPtr<async::future<T>>(std::move(f));
    return async::get([shared_f, c = std::forward<Callback>(c)] mutable -> ResultType {
        if constexpr (!std::is_void_v<ResultType>) {
            return c(shared_f->result());
        } else {
            shared_f->result();
            return c();
        }
    });
}
 
template <typename Callback>
auto original::operator|(async::future<void> f, Callback&& c)
{
    using ResultType = std::invoke_result_t<Callback>;
    strongPtr<async::future<void>> shared_f = makeStrongPtr<async::future<void>>(std::move(f));
    return async::get([shared_f, c = std::forward<Callback>(c)]() mutable -> ResultType {
        shared_f->result();
        return c();
    });
}
 
template <typename T, typename Callback>
auto original::operator|(async::sharedFuture<T> sf, Callback&& c)
{
    using ResultType = std::invoke_result_t<Callback, T>;
    return async::get([sf, c = std::forward<Callback>(c)] mutable -> ResultType {
        if constexpr (!std::is_void_v<ResultType>) {
            return c(sf.result());
        } else {
            sf.result();
            return c();
        }
    }).share();
}
 
template <typename Callback>
auto original::operator|(async::sharedFuture<void> sf, Callback&& c)
{
    using ResultType = std::invoke_result_t<Callback>;
    return async::get([sf, c = std::forward<Callback>(c)]() mutable -> ResultType {
        sf.result();
        return c();
    }).share();
}
 
template <typename T, typename Callback1, typename Callback2>
auto original::operator|(async::promise<T, Callback1> p, Callback2&& c)
{
    if (!p.valid()) {
        throw sysError("Try to build a lazy pipeline from an invalid promise");
    }
    using ResultType = decltype(c(std::declval<T>()));
    strongPtr<async::promise<T,Callback1>> shared_p = makeStrongPtr<async::promise<T, Callback1>>(std::move(p));
    return async::makePromise([shared_p, c = std::forward<Callback2>(c)]() mutable -> ResultType {
        if constexpr (!std::is_void_v<ResultType>) {
            return c(shared_p->function()());
        } else {
            shared_p->function()();
            return c();
        }
    });
}
 
template <typename Callback1, typename Callback2>
auto original::operator|(async::promise<void, Callback1> p, Callback2&& c)
{
    if (!p.valid()) {
        throw sysError("Try to build a lazy pipeline from an invalid promise");
    }
    using ResultType = decltype(c());
    strongPtr<async::promise<void, Callback1>> shared_p = makeStrongPtr<async::promise<void, Callback1>>(std::move(p));
    return async::makePromise([shared_p, c = std::forward<Callback2>(c)]() mutable -> ResultType {
        shared_p->function()();
        return c();
    });
}
 
inline void original::async::asyncWrapper<void>::setValue()
{
    {
        uniqueLock lock{this->mutex_};
        this->result_.set();
        this->ready_.store(true);
    }
    this->cond_.notify();
}
 
inline void original::async::asyncWrapper<void>::setException(std::exception_ptr e)
{
    {
        uniqueLock lock{this->mutex_};
        this->e_ = std::move(e);
        this->ready_.store(true);
    }
    this->cond_.notify();
}
 
inline bool original::async::asyncWrapper<void>::ready() const
{
    return this->ready_.load();
}
 
inline void original::async::asyncWrapper<void>::wait() const
{
    uniqueLock lock{this->mutex_};
    this->cond_.wait(this->mutex_, [this]
    {
        return this->ready();
    });
}
 
inline bool original::async::asyncWrapper<void>::waitFor(time::duration timeout) const
{
    uniqueLock lock{this->mutex_};
    return this->cond_.waitFor(this->mutex_, std::move(timeout), [this]
    {
       return this->ready();
    });
}
 
inline void original::async::asyncWrapper<void>::get()
{
    uniqueLock lock{this->mutex_};
    this->rethrowIfException();
    if (this->result_) {
        this->result_.reset();
        return;
    }
    this->cond_.wait(this->mutex_, [this] {
        return this->ready();
    });
 
    this->rethrowIfException();
    this->result_.reset();
}
 
inline void original::async::asyncWrapper<void>::peek() const
{
    uniqueLock lock{this->mutex_};
    this->rethrowIfException();
    if (this->result_) {
        return;
    }
    this->cond_.wait(this->mutex_, [this] {
        return this->ready();
    });
 
    this->rethrowIfException();
}
 
inline void original::async::asyncWrapper<void>::rethrowIfException() const
{
    if (this->e_)
        std::rethrow_exception(this->e_);
}
 
inline std::exception_ptr
original::async::asyncWrapper<void>::exception() const noexcept
{
    uniqueLock lock{this->mutex_};
    return this->e_;
}
 
inline original::async::future<void>::future(strongPtr<asyncWrapper<void>> awr)
    : awr_(std::move(awr)) {}
 
inline bool original::async::future<void>::valid() const noexcept
{
    return this->awr_ != nullptr;
}
 
inline original::async::sharedFuture<void> original::async::future<void>::share()
{
    return sharedFuture(std::move(this->awr_));
}
 
inline void original::async::future<void>::result()
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    this->awr_->get();
}
 
inline bool original::async::future<void>::ready() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    return this->awr_->ready();
}
 
inline std::exception_ptr original::async::future<void>::exception() const noexcept
{
    if (!this->valid()) {
        return {};
    }
    return this->awr_->exception();
}
 
inline void original::async::future<void>::wait() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    this->awr_->wait();
}
 
inline bool original::async::future<void>::waitFor(const time::duration timeout) const
{
    if (!this->valid()) {
        throw sysError("Access an invalid future");
    }
    return this->awr_->waitFor(timeout);
}
 
inline original::async::sharedFuture<void>::sharedFuture(strongPtr<asyncWrapper<void>> awr)
    : awr_(std::move(awr)) {}
 
inline bool original::async::sharedFuture<void>::valid() const noexcept
{
    return this->awr_ != nullptr;
}
 
inline void original::async::sharedFuture<void>::result() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    this->awr_->peek();
}
 
inline bool original::async::sharedFuture<void>::ready() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    return this->awr_->ready();
}
 
inline std::exception_ptr original::async::sharedFuture<void>::exception() const noexcept
{
    if (!this->valid()) {
        return {};
    }
    return this->awr_->exception();
}
 
inline bool original::async::sharedFuture<void>::operator==(const sharedFuture& other) const noexcept
{
    return this->awr_ == other.awr_;
}
 
inline bool original::async::sharedFuture<void>::operator!=(const sharedFuture& other) const noexcept
{
    return this->awr_ != other.awr_;
}
 
 
inline void original::async::sharedFuture<void>::wait() const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    this->awr_->wait();
}
 
inline bool original::async::sharedFuture<void>::waitFor(const time::duration timeout) const
{
    if (!this->valid()) {
        throw sysError("Access an invalid sharedFuture");
    }
    return this->awr_->waitFor(timeout);
}
 
inline original::u_integer original::async::sharedFuture<void>::toHash() const noexcept
{
    return this->awr_.toHash();
}
 
inline bool original::async::sharedFuture<void>::equals(const sharedFuture& other) const noexcept
{
    return *this == other;
}
 
template <typename Callback>
original::async::promise<void, Callback>::promise(promise&& other) noexcept
{
    if (!other.valid()){
        return;
    }
    this->valid_ = true;
    this->c_ = std::move(other.c_);
    this->awr_ = std::move(other.awr_);
    other.valid_ = false;
}
 
template <typename Callback>
original::async::promise<void, Callback>& original::async::promise<void, Callback>::operator=(promise&& other) noexcept
{
    if (this == &other || !other.valid()) {
        return *this;
    }
    this->valid_ = true;
    this->c_ = std::move(other.c_);
    this->awr_ = std::move(other.awr_);
    other.valid_ = false;
    return *this;
}
 
template <typename Callback>
original::async::promise<void, Callback>::promise(Callback&& c)
    : c_(std::forward<Callback>(c)), awr_(makeStrongPtr<asyncWrapper<void>>()), valid_(true) {}
 
template <typename Callback>
original::async::future<void> original::async::promise<void, Callback>::getFuture() const
{
    return future<void>(this->awr_);
}
 
template <typename Callback>
bool original::async::promise<void, Callback>::valid() const noexcept
{
    return this->valid_;
}
 
template <typename Callback>
std::function<void()> original::async::promise<void, Callback>::function()
{
    if (!this->valid_) {
        throw sysError("Try to get an invalid task");
    }
    this->valid_ = false;
    return std::move(this->c_);
}
 
template <typename Callback>
void original::async::promise<void, Callback>::run()
{
    if (!this->valid_) {
        throw sysError("Try to run an invalid task");
    }
    try {
        this->c_();
        this->awr_->setValue();
    } catch (...) {
        this->awr_->setException(std::current_exception());
    }
    this->valid_ = false;
}
 
#endif // ORIGINAL_ASYNC_H