Outcome.hpp

#pragma once
 
#include "util/async/context/impl/Cancellation.hpp"
 
#include <concepts>
#include <future>
 
namespace util::async {
 
template <typename RetType, typename StopSourceType>
class StoppableOperation;
 
namespace impl {
 
template <typename RetType>
class BasicOperation;

template <typename RetType>
class BasicOutcome {
protected:
    std::promise<RetType> promise_;
 
public:
    using DataType = RetType;
 
    BasicOutcome() = default;
    BasicOutcome(BasicOutcome&&) = default;
 
    BasicOutcome(BasicOutcome const&) = delete;

    void
    setValue(std::convertible_to<RetType> auto&& val)
    {
        promise_.set_value(std::forward<decltype(val)>(val));
    }

    void
    setValue()
    {
        promise_.set_value({});
    }

    [[nodiscard]] std::future<RetType>
    getStdFuture()
    {
        return promise_.get_future();
    }
};
 
}  // namespace impl

template <typename RetType>
class Outcome : public impl::BasicOutcome<RetType> {
public:
    [[nodiscard]] impl::BasicOperation<Outcome>
    getOperation()
    {
        return impl::BasicOperation<Outcome>{this};
    }
};

template <typename RetType, typename StopSourceType>
class StoppableOutcome : public impl::BasicOutcome<RetType> {
private:
    StopSourceType stopSource_;
 
public:
    [[nodiscard]] StoppableOperation<RetType, StopSourceType>
    getOperation()
    {
        return StoppableOperation<RetType, StopSourceType>{this};
    }

    [[nodiscard]] StopSourceType&
    getStopSource()
    {
        return stopSource_;
    }
};
 
}  // namespace util::async