uvco Namespace Reference

Namespaces
namespace	anonymous_namespace{async_work.cc}
namespace	anonymous_namespace{combinators.cc}
namespace	anonymous_namespace{curl.cc}
namespace	anonymous_namespace{fs.cc}
namespace	anonymous_namespace{loop.cc}
namespace	anonymous_namespace{name_resolution.cc}
namespace	anonymous_namespace{tcp.cc}
namespace	anonymous_namespace{uds_stream.cc}
namespace	detail
namespace	examples

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
class	Coroutine
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	LifetimeTracker
class	Loop
class	MultiPromise
class	MultiPromiseCore
class	OnExit
class	Pqxx
class	Promise
class	Promise< void >
class	PromiseCore
class	PromiseCore< void >
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	TaskSet
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
	A UDP socket. More...
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	WaitPoint
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::finished = 2 }

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 *handle)
template<typename Handle>
bool	isClosed (const Handle *h)
template<typename Handle, typename CloserArg>
void	closeHandle (Handle *handle, void(*closer)(CloserArg *, void(*)(uv_handle_t *)))
template<typename Handle>
void	closeHandle (Handle *handle)
	Specialization for uv_handle_t handles.
Promise< void >	yield ()
MultiPromise< unsigned >	yield (unsigned count)
	Generate count values from 0 to count - 1.
template<typename... PromiseTypes>
Promise< std::vector< std::variant< PromiseTypes... > > >	waitAny (Promise< PromiseTypes > &...promises)
template<typename... PromiseTypes>
Promise< std::vector< std::variant< PromiseTypes... > > >	race (Promise< PromiseTypes >... promises)
template<typename... PromiseTypes>
Promise< void >	raceIgnore (Promise< PromiseTypes >... promises)
template<typename... PromiseTypes>
Promise< std::tuple< typename detail::ReplaceVoid< PromiseTypes >::type... > >	waitAll (Promise< PromiseTypes >... promises)
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)
	Obtain data pointer set on handle with nullptr check and type cast.
template<typename Into, typename Handle>
Into *	getDataOrNull (const Handle *handle)
template<typename Into, typename Request>
Into *	getRequestData (const Request *req)
	Obtain data pointer set on request with nullptr check and type cast.
template<typename Into, typename Request>
Into *	getRequestDataOrNull (const Request *req)
template<typename Handle, typename Data>
void	setData (Handle *handle, Data *data)
	Obtain data pointer set on request with type cast. Data may be nullptr.
template<typename Handle>
void	resetData (Handle *handle)
	Reset data pointer on handle to nullptr.
template<typename Request, typename Data>
void	setRequestData (Request *req, Data *data)
	Set data pointer on request.
template<typename Request>
void	resetRequestData (Request *req)
template<typename Handle>
bool	dataIsNull (Handle *handle)
	Check if handle data is null.
template<typename Request>
bool	requestDataIsNull (Request *req)
	Check if request data is null.
std::pair< StreamBase, StreamBase >	pipe (const Loop &loop)
void	runLoop (Loop &loop)
template<typename R, MainFunction< R > F>
R	runMain (F main)
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
static constexpr bool	useSymmetricHandoff = true
static constexpr bool	logSchedulerOperations = false
	If set to true, log scheduler operations to stdout.

Function Documentation

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(); }

Variable Documentation

useSymmetricHandoff

bool uvco::useSymmetricHandoff = true

staticconstexpr

If set to true, always resume coroutines from the scheduler. Otherwise, coroutines may be resumed upon suspension of another coroutine. This can make control flow easier to understand and debug; coroutines being directly resumed upon resumption of another one may result in deep and random stacks, which is especially inconvenient when profiling code, as flamegraphs and other aggregates will show samples spread across many different stacks.