Struct Persisted 

pub struct Persisted<P>
where
    P: Persistence,
{ /* private fields */ }

Available on crate feature sleep only.

A backend that drives a Persistence instance to emit tasks

This provides a lightweight way to compose a backend without worrying about polling

Implementations

impl<P> Persisted<P>

where P: Persistence + Clone, P::Compact: Send + 'static, P::Response: Send,

pub fn new(inner: P) -> Self

Creates a new Persisted in the NotBootstrapped state.

The worker will register itself with the backend on the first call to poll_ready.

pub fn state(&self) -> &State<Task<P::Compact>, P::Error>

Get the current state

pub fn state_mut(&mut self) -> &mut State<Task<P::Compact>, P::Error>

Get the a mutable state

pub fn layer<C>( &mut self, codec: C, batch_size: usize, ) -> TaskPersistLayer<C, P::Response>

Build a layer that wraps a TaskPersistLayer

pub fn poll_ready( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, heartbeat_interval: Duration, ) -> Poll<Result<(), P::Error>>

Drives the provider’s internal state machine (bootstrap, heartbeat, event processing) until it is genuinely ready for poll_next to be called, or until it must return Pending.

pub fn poll_next( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Option<Result<Task<P::Compact>, P::Error>>>

Pulls the next task from the backend, fetching a fresh batch when the internal buffer is exhausted.

Assumes poll_ready has already driven the state machine into State::Ready; other states fall through to Pending since they’re the responsibility of poll_ready/poll_close.

pub fn poll_close( &mut self, cx: &mut Context<'_>, worker: &WorkerContext, ) -> Poll<Result<(), P::Error>>

Gracefully winds down the provider: finishes in-flight bootstrap/heartbeat event futures, re-enqueues any abandoned buffered tasks, then flushes remaining events before signalling completion.

Trait Implementations

impl<P> Clone for Persisted<P>

where P: Persistence + Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Debug for Persisted<P>

where P: Persistence + Debug, P::Compact: Debug, P::Error: Debug, P::Response: Debug,

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

Formats the value using the given formatter.

impl<P> Deref for Persisted<P>

where P: Persistence,

type Target = P

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<P> DerefMut for Persisted<P>

where P: Persistence,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<P> Sink<Task<<P as Persistence>::Compact>> for Persisted<P>

where P: Persistence + Unpin, P::Compact: Send + Unpin + 'static,

type Error = <P as Persistence>::Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, _cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send( self: Pin<&mut Self>, item: Task<P::Compact>, ) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.