Threadpool

Classes
class	uvco::ThreadLocalKey< T >

Functions
Promise< void >	uvco::innerSubmitWork (const Loop &loop, std::function< void()> work)
	Do not use; instead, use submitWork<void>().
template<typename R> requires std::is_void_v<R> || std::is_move_constructible_v<R>
Promise< R >	uvco::submitWork (const Loop &loop, std::function< R()> work)
template<>
Promise< void >	uvco::submitWork (const Loop &loop, std::function< void()> work)

Detailed Description

Function Documentation

innerSubmitWork()

Promise< void > uvco::innerSubmitWork	(	const Loop &	loop,
		std::function< void()>	work )

Do not use; instead, use submitWork<void>().

                                                                          {
  AsyncWorkAwaiter_ awaiter{std::move(work)};
  uv_queue_work(loop.uvloop(), &awaiter.work(), AsyncWorkAwaiter_::onDoWork,
                AsyncWorkAwaiter_::onWorkDone);
  co_await awaiter;
  co_return;
}

submitWork() [1/2]

template<typename R>
requires std::is_void_v<R> || std::is_move_constructible_v<R>

Promise< R > uvco::submitWork	(	const Loop &	loop,
		std::function< R()>	work )

Submit a function to be run on the libuv threadpool. The promise will return the function's return value.

                                                               {
  std::optional<std::variant<R, std::exception_ptr>> result;
  // Erase return type and use generic submitWork().
  std::function<void()> agnosticWork = [&result, work]() {
    try {
      result = work();
    } catch (...) {
      result = std::current_exception();
    }
  };
  co_await innerSubmitWork(loop, std::move(agnosticWork));
  BOOST_ASSERT(result.has_value());
  if (result->index() == 1) {
    std::rethrow_exception(std::get<std::exception_ptr>(*result));
  }
  co_return std::get<R>(std::move(*result));
}

submitWork() [2/2]

template<>

Promise< void > uvco::submitWork	(	const Loop &	loop,
		std::function< void()>	work )

                                                                     {
  std::optional<std::exception_ptr> result;
  // Transport exception back to submitter.
  std::function<void()> agnosticWork = [&result, work = std::move(work)]() {
    try {
      work();
    } catch (...) {
      result = std::current_exception();
    }
  };
  co_await innerSubmitWork(loop, std::move(agnosticWork));
  if (result.has_value()) {
    std::rethrow_exception(result.value());
  }
  co_return;
}