Glossary

An I/O object that listens for and accepts incoming TCP connections. See corosio::acceptor and Acceptors Guide.

An awaitable type that implements the affine protocol, receiving a dispatcher parameter in await_suspend to ensure correct executor affinity.

The binding of a coroutine to a specific executor. A coroutine with affinity to executor ex will have all its resumptions dispatched through ex.

A type-erased reference to a buffer sequence, allowing non-template code to work with any buffer type.

A type-erased wrapper for dispatchers, enabling runtime polymorphism for executor types.

A type that can be used with co_await. Must provide await_ready(), await_suspend(), and await_resume() methods.

A contiguous region of memory. See capy::mutable_buffer (writable) and capy::const_buffer (read-only).

A collection of buffers that can be iterated. Enables scatter/gather I/O with a single operation.

The ability to abort an in-progress asynchronous operation. Operations complete with an error code indicating cancellation.

The event when an asynchronous operation finishes, either successfully or with an error.

An operation built from multiple primitive operations. For example, corosio::read() repeatedly calls read_some() until the buffer is full.

A value passed to io_context indicating how many threads may call run(). Affects internal synchronization strategy.

The code that runs after an asynchronous operation completes. In coroutines, this is the code following co_await.

A function that can suspend and resume execution. Uses co_await, co_yield, or co_return keywords.

A low-level handle to a suspended coroutine, represented by std::coroutine_handle<>.

An object that can dispatch coroutine handles for execution. Satisfies the capy::dispatcher concept.

A combination of IP address and port number identifying a network destination. See corosio::endpoint.

A condition indicating no more data is available. Signaled by capy::error::eof.

A grouping of related error codes. Boost.System uses categories to distinguish different error sources.

A lightweight error indicator. See boost::system::error_code.

A portable error classification. Enables comparing errors across categories.

An environment where work runs. Provides service management and an executor. See capy::execution_context.

An object that can dispatch work for execution. Satisfies the capy::executor concept.

A reference to a system resource (socket, file, etc.) managed by the operating system.

A callback function or coroutine handle that runs when an operation completes.

The main event loop in Corosio. Processes asynchronous operations and dispatches completions. See corosio::io_context.

A class representing an I/O resource (socket, timer, etc.). Base class is corosio::io_object.

An I/O object that supports reading and writing data. Base class is corosio::io_stream.

The result type for Corosio operations, containing an error code and optional values. Supports structured bindings.

Windows kernel mechanism for scalable asynchronous I/O. Used by Corosio on Windows.

A coroutine or operation that doesn’t start until explicitly triggered. capy::task is lazy—it starts when awaited.

A mock socket for testing. See corosio::test::mocket.

A type that can be moved but not copied. Sockets and other I/O objects are move-only.

An asynchronous action that completes in the future. Returns an awaitable that can be `co_await`ed.

Work tracked by an I/O context. The context’s run() continues while outstanding work exists.

The operating system-specific implementation (IOCP, io_uring, kqueue).

Processing ready work without blocking. See io_context::poll().

Queuing work for later execution. See executor_type::post().

A basic I/O operation like read_some() or write_some() that may transfer any amount of data.

An I/O object that performs DNS lookups. See corosio::resolver.

Continuing execution of a suspended coroutine.

Processing the event loop. See io_context::run().

Reading into or writing from multiple non-contiguous buffers in a single operation.

A polymorphic component owned by an execution context. Provides shared functionality.

An I/O object that waits for operating system signals. See corosio::signal_set.

An I/O object for TCP network communication. See corosio::socket.

A mechanism for requesting cancellation. See std::stop_token.

A serialization mechanism that ensures handlers don’t run concurrently. Operations posted to a strand execute one at a time, eliminating data races without mutexes. See Concurrent Programming.

A sequence of bytes that can be read or written incrementally.

C++17 feature for unpacking tuple-like types: auto [a, b] = expr;

Pausing execution of a coroutine, yielding control to the caller.

A tail-call optimization where one coroutine directly resumes another without stack growth.

A lazy coroutine that produces a value. See capy::task<T>.

A framework class for building TCP servers with worker pools. See corosio::tcp_server and TCP Server Guide.

The ability to use an object safely from multiple threads. Individual I/O objects are generally not thread-safe.

An I/O object for scheduling delays. See corosio::timer.

Cryptographic protocol for secure communication. See corosio::wolfssl_stream.

Hiding concrete types behind an abstract interface. Enables runtime polymorphism without templates.

An operation that suspends until a condition is met (timer expires, signal received, etc.).

A compact TLS library used by Corosio for secure streams.

Pending operations that keep an I/O context running.

A design pattern where a fixed number of worker objects are preallocated to handle connections. Provides bounded resource usage and avoids allocation during operation. See TCP Server.