Glossary

An I/O object that listens for and accepts incoming connections. See tcp_acceptor and Acceptors Guide.

An awaitable type that implements the affine protocol. It receives an io_env const* in await_suspend, carrying the executor, stop token, and frame allocator, to ensure correct executor affinity.

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

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

A type-erased wrapper for executors, enabling runtime polymorphism for executor types. See capy::any_executor.

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.

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

An operation built from multiple primitive operations. For example, capy::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<>.

A stateless suspension for a duration or until a time point. See corosio::delay() and Delays and Timeouts.

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::cond::eof.

A grouping of related error codes. The standard library uses categories to distinguish different error sources (system, generic, and capy).

A lightweight error indicator. See std::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 or post coroutine handles and work for execution. Satisfies the capy::Executor concept.

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

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

A class representing an I/O resource (socket, resolver, 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 filesystem path used as the address for a Unix domain socket. Represented by corosio::local_endpoint. See Unix Domain Sockets.

The in-process test double for a socket. 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 I/O implementation. Corosio provides five: epoll, kqueue, IOCP, io_uring, and select. The default selection is IOCP (Windows), epoll (Linux), kqueue (BSD/macOS), and select (fallback); io_uring is available but not selected by default.

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 resolves host names to addresses. See 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 network communication. See tcp_socket.

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

A serialization mechanism that ensures handlers don’t run concurrently, so operations execute one at a time, eliminating data races without mutexes. Corosio does not provide a strand type; the equivalent is executor affinity or a single-threaded io_context. 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 not thread-safe.

Racing an awaitable against a deadline. See corosio::timeout() and Delays and Timeouts.

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

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

A socket that communicates between processes on the same machine using filesystem paths instead of IP addresses and ports. Available as stream (local_stream_socket) and datagram (local_datagram_socket) variants. See Unix Domain Sockets.

An operation that suspends until a condition is met (a delay elapses, a socket becomes ready, a signal is 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.