Struct Ctx 

pub struct Ctx<K>(pub <K as CtxKey>::Value)
where
    K: CtxKey;

Extractor that injects one broker context field into a handler, by its key.

Where State<T> pulls a value out of the shared application state, Ctx<K> pulls one field out of the broker’s per-delivery context: Ctx(offset): Ctx<Offset> binds the value the key Offset reads. The key implements ContextField, which names the context type it reads from - so a handler using only Ctx extractors needs no &mut Context parameter at all: the #[subscriber] macro projects the subscription’s context type from the first Ctx key in the signature. With a &mut Context<'_, C> parameter also present, the keys must read that same C (the compiler enforces it).

Values are owned (ContextField::Value is 'static): extractors bind before the handler body runs, so borrowing from the context is not an option. Keys yielding borrowed values stay readable through ctx.context(KEY).

Examples

use ruststream::ContextField;
use ruststream::prelude::*;
use serde::Deserialize;

/// A broker's per-delivery context, and its key for the offset a delivery sits at.
struct Delivery {
    offset: u64,
}

#[derive(Clone, Copy, Default)]
struct Offset;

impl ContextField for Offset {
    type Context = Delivery;
    type Value = u64;
    fn read(self, src: &Delivery) -> u64 {
        src.offset
    }
}

#[derive(Deserialize)]
struct Order {
    id: u64,
}

#[subscriber("orders")]
async fn audit(order: &Order, Ctx(offset): Ctx<Offset>) -> HandlerOutcome {
    tracing::info!(order.id, offset, "audited");
    HandlerOutcome::ack()
}

Tuple Fields

0: <K as CtxKey>::Value

Trait Implementations

impl<K> Debug for Ctx<K>

where K: CtxKey, <K as CtxKey>::Value: Debug,

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

Formats the value using the given formatter.

impl<S, K> FromContext<<K as ContextField>::Context, S> for Ctx<K>

where K: ContextField, <K as ContextField>::Context: Send, S: Sync,

type Rejection = !

The error returned when extraction fails. It is converted into a HandlerOutcome (the reflexive conversion makes HandlerOutcome itself a valid rejection, and Infallible works for an extractor that never fails) and the delivery is settled by that outcome, skipping the handler body.

fn from_context( ctx: &mut Context<'_, <K as ContextField>::Context, S>, ) -> impl Future<Output = Result<Ctx<K>, !>> + Send

Resolves the value from the delivery context. The context is borrowed mutably so an extractor may also read broker fields or take scratch a middleware left for it.

impl<C, S> FromContext<C, S> for Ctx<MainRuntime>

where C: Send, S: Sync,

type Rejection = !

The error returned when extraction fails. It is converted into a HandlerOutcome (the reflexive conversion makes HandlerOutcome itself a valid rejection, and Infallible works for an extractor that never fails) and the delivery is settled by that outcome, skipping the handler body.

fn from_context( ctx: &mut Context<'_, C, S>, ) -> impl Future<Output = Result<Ctx<MainRuntime>, !>> + Send

Resolves the value from the delivery context. The context is borrowed mutably so an extractor may also read broker fields or take scratch a middleware left for it.