Struct Completion 

pub struct Completion { /* private fields */ }

Implementations

impl Completion

pub fn new(completion_type: CompletionType) -> Self

pub fn keep_write_buffer_alive(&self, buf: Arc<Buffer>)

Stores a write buffer reference in the completion to keep it alive until the I/O completes. Required for async backends (io_uring, VFS) where pwrite returns before the kernel has consumed the buffer.

pub fn new_write<F>(complete: F) -> Self

where F: Fn(Result<i32, CompletionError>) + Send + Sync + 'static,

pub fn new_read<F>(buf: Arc<Buffer>, complete: F) -> Self

where F: Fn(Result<(Arc<Buffer>, i32), CompletionError>) -> Option<CompletionError> + Send + Sync + 'static,

pub fn new_sync<F>(complete: F) -> Self

where F: Fn(Result<i32, CompletionError>) + Send + Sync + 'static,

pub fn new_trunc<F>(complete: F) -> Self

where F: Fn(Result<i32, CompletionError>) + Send + Sync + 'static,

pub fn new_yield() -> Self

Create a yield completion. These are completed by default allowing to yield control without allocating memory.

pub fn wake(&self)

pub fn wake_progress(&self)

Fire a “progress wake” without consuming the completion’s result — wakes the waker on this completion and on its parent group, if any. Used by IO backends to nudge the future when an operation made progress but isn’t fully done (e.g. an io_uring writev that completed only the first chunk and was resubmitted internally). Without this, a poll whose drained CQEs are all intermediate-chunk completions returns without waking anything, and since step() is the only thing that drains the CQ, the resubmitted chunks pile up and the task deadlocks.

pub fn set_waker(&self, waker: &Waker)

pub fn succeeded(&self) -> bool

pub fn failed(&self) -> bool

pub fn get_error(&self) -> Option<CompletionError>

pub fn finished(&self) -> bool

Checks if the Completion completed or errored

pub fn is_explicit_yield(&self) -> bool

Returns true if this completion is an explicit yield — a signal to return control to the cooperative scheduler so other connections can make progress. Unlike real I/O completions that happen to be finished, yield completions must not be treated as “ready to continue immediately” because the yielding operation is waiting on external state (e.g. a lock held by another fiber) that can only change when other fibers are stepped.

pub fn complete(&self, result: i32)

pub fn error(&self, err: CompletionError)

pub fn abort(&self)

pub fn as_read(&self) -> &ReadCompletion

only call this method if you are sure that the completion is a ReadCompletion, panics otherwise

Trait Implementations

impl Clone for Completion

fn clone(&self) -> Completion

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Completion

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Future for Completion

type Output = Result<(), LimboError>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.