future_value.hpp

Go to the documentation of this file.

#pragma once
#include "async.hpp"
#include "buffers.hpp"
 
namespace uni20::async
{
 
template <typename T> class FutureValue {
  public:
    using value_type = T;
 
    FutureValue() : async_{}, write_buf_{async_.write()} {}
 
    FutureValue(FutureValue&&) noexcept = default;
    FutureValue& operator=(FutureValue&&) noexcept = default;
 
    FutureValue(FutureValue const&) = delete;
 
    Async<T> const& async() const noexcept { return async_; }
 
    ReadBuffer<T> read() const { return async_.read(); }
 
    [[nodiscard]] WriteBuffer<T> write() noexcept { return std::move(write_buf_); }
 
    template <typename U>
    FutureValue& operator=(U&& v)
      requires std::constructible_from<T, U&&>
    {
      write_buf_.emplace_assert(std::forward<U>(v));
      write_buf_.release();
      return *this;
    }
 
    template <typename U> FutureValue& operator=(Async<U> const& v)
    {
      async_assign(std::move(write_buf_), v.read());
      return *this;
    }
 
    template <typename U> FutureValue& operator=(Async<U>&& v)
    {
      async_move(std::move(write_buf_), std::move(v));
      return *this;
    }
 
    Async<T>& value() { return async_; }
    Async<T> const& value() const { return async_; }
 
  private:
    Async<T> async_;
    WriteBuffer<T> write_buf_;
};
 
template <typename T> class Defer {
  public:
    using value_type = T;
 
    Defer(Defer&&) = default;
 
    Defer() = delete;
    Defer(Defer const&) = delete;
    Defer& operator=(Defer&&) = delete;
    Defer& operator=(Defer const&) = delete;
 
    explicit Defer(Async<T>& w) : writer_(w.write()) {}
 
    explicit Defer(WriteBuffer<T>&& w) : writer_(std::move(w)) {}
 
    template <typename U>
      requires std::constructible_from<T, U&&>
    void write_assert(U&& val)
    {
      writer_.emplace_assert(std::forward<U>(val));
    }
 
    template <typename U>
      requires std::assignable_from<T&, async_value_t<U>>
    void operator=(U&& val)
    {
      async_assign(std::move(writer_), std::forward<U>(val));
    }
 
    [[nodiscard]] WriteProxy<T> write() { return writer_.write(); }
 
    void release() { writer_.release(); }
 
  private:
    WriteBuffer<T> writer_;
};
 
template <typename T> Defer(Async<T>&) -> Defer<T>;
 
template <typename T> Defer<T> defer_write(Async<T>& a) { return Defer<T>(a); }
 
} // namespace uni20::async