async_impl.hpp

Go to the documentation of this file.

#pragma once
 
#include "async_ops.hpp"
#include "async_task_promise.hpp"
#include "buffers.hpp"
 
namespace uni20::async
{
 
template <typename T>
template <typename U>
  requires detail::async_assignment_source<T, U>
Async<T>& Async<T>::operator=(U&& rhs)
{
  if constexpr (!is_async_alias_v<T>)
  {
    if constexpr (detail::async_source<U>)
    {
      Async<T> replacement;
      async_initialize(replacement, std::forward<U>(rhs));
      *this = std::move(replacement);
    }
    else
    {
      *this = Async<T>(std::forward<U>(rhs));
    }
  }
  else
  {
    async_assign(*this, std::forward<U>(rhs));
  }
  return *this;
}
 
template <typename T> void Async<T>::wait() const { this->read().wait(); }
 
template <typename T> void Async<T>::wait(IAsyncScheduler& sched) const { this->read().wait(sched); }
 
template <typename T> T const& Async<T>::get_wait() const { return this->read().get_wait(); }
 
template <typename T> T const& Async<T>::get_wait(IAsyncScheduler& sched) const { return this->read().get_wait(sched); }
 
template <typename T>
T Async<T>::move_from_wait()
  requires(!is_async_alias_v<T> && std::constructible_from<T, T &&>)
{
  return this->write().move_from_wait();
}
 
template <TaskAwaitable A> inline auto TaskPromiseBase::await_transform(A& a) { return TaskAwaiter<A&>(a, *this); }
 
template <TaskAwaitable A> inline auto TaskPromiseBase::await_transform(A&& a)
{
  return TaskAwaiter<std::remove_reference_t<A>>(std::move(a), *this);
}
 
template <TaskFactoryAwaitable A> inline auto TaskPromiseBase::await_transform(A& a)
{
  return TaskFactoryAwaiter<A&>(a, *this);
}
 
template <TaskFactoryAwaitable A> inline auto TaskPromiseBase::await_transform(A&& a)
{
  return TaskFactoryAwaiter<std::remove_reference_t<A>>(std::move(a), *this);
}
 
} // namespace uni20::async