Struct State 

pub struct State<T>(pub T);

Extractor that injects a piece of the shared application state into a handler.

State<T> resolves through FromContext whenever T: FromRef<S>, so a handler can take State<T> for any state component - including types defined in other crates (a broker publisher, a client pool), which a per-field FromContext impl could not cover under the orphan rule. Derive FromRef on the state to make every field available.

Examples

use std::convert::Infallible;

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

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

#[derive(Clone)]
struct Pricing {
    currency: &'static str,
}

#[derive(Clone)]
struct Region(&'static str);

/// Each field is a component a handler takes with `State<T>`.
#[derive(FromRef)]
struct AppState {
    pricing: Pricing,
    region: Region,
}

#[subscriber("orders")]
async fn price(order: &Order, State(pricing): State<Pricing>) -> HandlerOutcome {
    tracing::info!(order.id, pricing.currency, "priced");
    HandlerOutcome::ack()
}

fn app() -> impl App {
    RustStream::new(AppInfo::new("pricing", "0.1.0"))
        .on_startup(async move |()| {
            Ok::<_, Infallible>(AppState {
                pricing: Pricing { currency: "EUR" },
                region: Region("eu"),
            })
        })
        .with_broker(MemoryBroker::new(), |b| {
            b.include(price);
        })
}

Tuple Fields

0: T

Trait Implementations

impl<T> Clone for State<T>

where T: Clone,

fn clone(&self) -> State<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for State<T>

where T: Copy,

impl<T> Debug for State<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<C, S, T> FromContext<C, S> for State<T>

where T: FromRef<S> + Send,

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<State<T>, !>> + 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.