Struct SuspendBuilder 

pub struct SuspendBuilder<'a, T> { /* private fields */ }

Builder for a suspend point with optional status message.

Created by Context::suspend. Implements IntoFuture so it can be .awaited directly or chained with .status().

Examples

use memable::{Context, EngineError, SuspendPoint};

const WAIT: SuspendPoint<String> = SuspendPoint::new("wait:v1");
const APPROVAL: SuspendPoint<bool> = SuspendPoint::new("approval:v1");

async fn workflow(ctx: Context) -> Result<(), EngineError> {
    // Simple suspend — status defaults to the step key.
    let payload: String = ctx.suspend(&WAIT).await?;

    // Suspend with custom status message.
    let approved: bool = ctx.suspend(&APPROVAL)
        .status("Waiting for manager approval")
        .await?;
    Ok(())
}

Implementations

impl<'a, T> SuspendBuilder<'a, T>

where T: Serialize + DeserializeOwned + Send,

pub fn status(self, msg: &'a str) -> Self

Sets a custom status message for the suspended state.

If not called, the status defaults to the step key.

Examples

let approved: bool = ctx.suspend(&APPROVAL)
    .status("Waiting for manager approval")
    .await?;

Trait Implementations

impl<'a, T> IntoFuture for SuspendBuilder<'a, T>

where T: Serialize + DeserializeOwned + Send + 'a,

type Output = Result<T, EngineError>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <SuspendBuilder<'a, T> as IntoFuture>::Output> + Send + 'a>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.