Struct TransferCompleteNotification 

pub struct TransferCompleteNotification { /* private fields */ }

Notification handle for an in-progress transfer.

This object can be awaited to block until the transfer completes. The transfer is tracked by a background handler that polls for completion or processes notification events.

Uses futures::Either to avoid event system overhead for synchronous completions. Pending transfers use LocalEventWaiter which avoids heap allocation and repeated DashMap lookups when awaiting.

Implementations

impl TransferCompleteNotification

pub fn completed() -> Self

Create a notification that is already completed (for synchronous transfers).

This is useful for transfers that complete immediately without needing background polling, such as memcpy operations.

This is extremely efficient - no allocations, locks, or event system overhead.

pub fn from_awaiter(awaiter: EventAwaiter) -> Self

Create a notification from a LocalEventWaiter.

This is the primary way to construct a notification when you already have an event waiter from the event system.

pub fn could_yield(&self) -> bool

Check if the notification can yield the current task.

The internal ::Left arm is guaranteed to be ready, while the ::Right arm is not.

pub fn aggregate( notifications: Vec<Self>, events: &Arc<EventManager>, runtime: &Handle, ) -> Result<Self>

Aggregate multiple notifications into one that completes when all are done.

This is useful when a transfer is split across multiple workers and you want to wait for all of them to complete.

Arguments

• notifications - The notifications to aggregate
• events - The event system to create the aggregate event
• runtime - The tokio runtime handle to spawn the aggregation task

Behavior

• If the list is empty, returns an already-completed notification
• If there’s only one, returns it directly
• Otherwise, creates a new event and spawns a task to await all notifications

Trait Implementations

impl IntoFuture for TransferCompleteNotification

type Output = Result<(), Error>

The output that the future will produce on completion.

type IntoFuture = Either<Ready<Result<(), Error>>, TransferAwaiter>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.