uvco Namespace Reference

Namespaces
namespace	anonymous_namespace{async_work.cc}
namespace	anonymous_namespace{curl.cc}
namespace	anonymous_namespace{fs.cc}
namespace	anonymous_namespace{run.cc}
namespace	anonymous_namespace{scheduler.cc}
namespace	anonymous_namespace{uds_stream.cc}

Classes
class	AddressHandle
	AddressHandle is a light-weight wrapper around a struct sockaddr_in(6), and is therefore cheap to copy. More...
class	BoundedQueue
class	Channel
struct	CloseAwaiter
class	Coroutine
	A coroutine object used internally by C++20 coroutines ("promise object"). More...
class	Coroutine< void >
class	Curl
class	CurlException
class	CurlRequest
class	CurlRequestCore_
	Used as awaiter by Curl::download. More...
class	Directory
class	File
	A file descriptor. More...
class	FlagGuard
class	FsWatch
class	Generator
class	GenericAwaiter
class	LifetimeTracker
class	Loop
class	MultiPromise
class	MultiPromiseCore
class	Pqxx
class	Promise
class	Promise< void >
class	PromiseCore
class	PromiseCore< void >
class	PromiseHandle
class	RefCounted
class	Resolver
	Asynchronous name resolution using the libuv getaddrinfo(3) interface. More...
class	Scheduler
class	SelectSet
class	StreamBase
	A plain stream, permitting reading, writing, and closing. More...
class	StreamServerBase
class	TcpClient
	A client for connecting to a TCP peer. More...
class	TcpServer
class	TcpStream
class	ThreadLocalKey
class	Ticker
class	TickerImpl
	Non-movable, non-copyable: because the awaiter is called by a callback. More...
class	TimerAwaiter
class	TtyStream
class	Udp
class	UnixStream
class	UnixStreamClient
class	UnixStreamServer
struct	UvcoException
class	UvCurlContext_
struct	UvHandleDeleter
struct	UvStreamInitHelper
struct	UvStreamInitHelper< uv_pipe_t >
struct	UvStreamInitHelper< uv_tcp_t >
class	ZeroAtExit

Concepts
concept	WithTxFn
concept	MainFunction

Typedefs
using	uv_status = int
	Result of a libuv operation, an errno error code.

Enumerations
enum class	PromiseState { PromiseState::init = 0 , PromiseState::waitedOn = 1 , PromiseState::resuming = 2 , PromiseState::finished = 3 }

Functions
Promise< void >	innerSubmitWork (const Loop &loop, std::function< void()> work)
	Do not use; instead, use submitWork<void>().
template<>
Promise< void >	submitWork (const Loop &loop, std::function< void()> work)
template<typename R > requires std::is_void_v<R> || std::is_move_constructible_v<R>
Promise< R >	submitWork (const Loop &loop, std::function< R()> work)
template<>
Promise< void >	submitWork (const Loop &loop, std::function< void()> work)
void	onCloseCallback (uv_handle_t *stream)
template<typename T , typename C >
Promise< void >	closeHandle (T *handle, C closer)
template<typename T >
Promise< void >	closeHandle (T *handle)
void	allocator (uv_handle_t *, size_t sugg, uv_buf_t *buf)
	libuv allocator.
void	freeUvBuf (const uv_buf_t *buf)
template<typename R , typename F > requires std::is_invocable_r_v<R, F, std::string_view>
R	callWithNullTerminated (std::string_view view, F &&f)
template<typename Into , typename Handle >
Into *	getData (const Handle *handle)
template<typename Into , typename Request >
Into *	getRequestData (const Request *req)
template<typename Handle , typename Data >
void	setData (Handle *handle, Data *data)
template<typename Request , typename Data >
void	setRequestData (Request *req, Data *data)
template<typename Handle >
bool	dataIsNull (Handle *handle)
template<typename Request >
bool	requestDataIsNull (Request *req)
template<typename T , typename... Args> requires std::derived_from<T, RefCounted<T>>
T *	makeRefCounted (Args... args)
	Create a new refcounted value. T must derive from RefCounted<T>.
std::pair< StreamBase, StreamBase >	pipe (const Loop &loop)
Promise< void >	yield ()
	Suspend current coroutine until next event loop iteration.
MultiPromise< unsigned >	yield (unsigned count)
	Generate count values from 0 to count - 1.
void	runLoop (Loop &loop)
template<typename R , MainFunction< R > F>
R	runMain (F main, Scheduler::RunMode mode=Scheduler::RunMode::Deferred)
void	onSingleTimerDone (uv_timer_t *handle)
void	onMultiTimerFired (uv_timer_t *handle)
Promise< void >	sleep (const Loop &loop, uint64_t millis)
	A promise that resolves after at least millis milliseconds.
std::unique_ptr< Ticker >	tick (const Loop &loop, uint64_t millis, uint64_t count)

Variables
const bool	TRACK_LIFETIMES = true

Function Documentation

closeHandle() [1/2]

template<typename T >

Promise< void > uvco::closeHandle

(

T *

handle

)

                                                           {
  return closeHandle((uv_handle_t *)handle, uv_close);
}

closeHandle() [2/2]

template<typename T , typename C >

Promise< void > uvco::closeHandle	(	T *	handle,
		C	closer
	)

                                               {
  BOOST_ASSERT(handle != nullptr);
  CloseAwaiter awaiter{};
  setData(handle, &awaiter);
  closer(handle, onCloseCallback);
  co_await awaiter;
  setData(handle, (void *)nullptr);
  BOOST_ASSERT(awaiter.closed_);
}

onCloseCallback()

void uvco::onCloseCallback

(

uv_handle_t *

stream

)

                                          {
  auto *awaiter = getData<CloseAwaiter>(stream);
  awaiter->closed_ = true;
  if (awaiter->handle_) {
    auto handle = *awaiter->handle_;
    awaiter->handle_.reset();
    Loop::enqueue(handle);
  }
}

onMultiTimerFired()

void uvco::onMultiTimerFired

(

uv_timer_t *

handle

)

                                           {
  auto *awaiter = getData<TimerAwaiter>(handle);
  awaiter->resume();
}

onSingleTimerDone()

void uvco::onSingleTimerDone

(

uv_timer_t *

handle

)

                                           {
  auto *awaiter = getData<TimerAwaiter>(handle);
  awaiter->stop();
  awaiter->resume();
}

runLoop()

void uvco::runLoop

(

Loop &

loop

)

{ loop.run(); }