Struct Next 

pub struct Next<'a> { /* private fields */ }

The continuation an Interceptor calls to run the rest of the chain.

Next holds the still-to-run interceptors and the terminal handler. run consumes it; not calling it short-circuits the chain.

Next is also Clone (two shared references) for the interceptor that must run the rest of the chain more than once — a retry or a hedge. Clone before the first run and copy the request with UnaryRequest::try_clone:

let spare = req.try_clone()?;            // ctx clone + Payload::try_clone
match next.clone().run(req).await {
    Err(e) if e.code == ErrorCode::Unavailable => next.run(spare).await,
    done => done,
}

Re-running dispatches the inner interceptors and the terminal again. On the server that means invoking the handler twice, so gate any re-run on Spec::idempotency_level. Every attempt shares the one request deadline (a retry cannot extend it) and the one request tracing span; open a span per attempt if they need to be observable separately.

Implementations

impl<'a> Next<'a>

pub async fn run(self, req: UnaryRequest) -> Result<UnaryResponse, ConnectError>

Run the rest of the chain — the next interceptor if any, otherwise the terminal handler — and return its response. Consumes self; see Next for re-running.

Errors

Returns whatever error the next interceptor or handler produced.

Trait Implementations

impl<'a> Clone for Next<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Next<'_>

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

Formats the value using the given formatter.