Struct AsyncAppWithState 

pub struct AsyncAppWithState<S> { /* private fields */ }

An Application whose route handlers are async functions.

State is stored as Arc<S> and passed by value (cheap clone) to each handler invocation. Handlers receive owned Request, PathParams, and ConnectionInfo values so the returned future is 'static.

Implementations

impl<S: Send + Sync + 'static> AsyncAppWithState<S>

pub fn new(state: S) -> Self

Create a new AsyncAppWithState wrapping state.

pub fn with_config(self, config: ServerConfig) -> Self

Pin the fallback App (used for any request this app’s own routes don’t match) to an explicit crate::server_config::ServerConfig, instead of reading RWS_CONFIG_* environment variables per request.

Mirrors App::with_config / crate::state::AppWithState::with_config.

pub fn state(&self) -> &S

Return a reference to the shared state.

pub fn route_entries(&self) -> Vec<RouteInfo>

Return a snapshot of all registered routes as (method, pattern) pairs.

pub fn get<F, Fut>(self, pattern: &str, handler: F) -> Self

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async GET handler for pattern.

pub fn post<F, Fut>(self, pattern: &str, handler: F) -> Self

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async POST handler for pattern.

pub fn put<F, Fut>(self, pattern: &str, handler: F) -> Self

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async PUT handler for pattern.

pub fn patch<F, Fut>(self, pattern: &str, handler: F) -> Self

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async PATCH handler for pattern.

pub fn delete<F, Fut>(self, pattern: &str, handler: F) -> Self

where F: Fn(Request, PathParams, ConnectionInfo, Arc<S>) -> Fut + Send + Sync + 'static, Fut: Future<Output = Response> + Send + 'static,

Register an async DELETE handler for pattern.

Trait Implementations

impl<S: Send + Sync + 'static> Application for AsyncAppWithState<S>

fn execute( &self, request: &Request, connection: &ConnectionInfo, ) -> Result<Response, String>

Receives a parsed request and returns a fully-built response. Walk your controller list with is_matching / process and return the first match.

fn runs_inline(&self, _request: &Request, _connection: &ConnectionInfo) -> bool

true when executing request is quick and never waits on anything but the local filesystem — health checks, metrics, small static files. The async servers (HTTP/1.1, HTTP/2, HTTP/3) then call execute directly on the event loop, as nginx does, instead of handing the request to tokio’s blocking pool: that handoff (a shared lock and two cross-thread wake-ups) costs more than serving a small file.

fn execute_async<'a>( &'a self, _request: &'a Request, _connection: &'a ConnectionInfo, ) -> Option<AsyncResponse<'a>>

An asynchronous version of execute for this request, when the application has one: the async servers await it on the connection’s task instead of tying up a blocking-pool thread while it waits (the config-driven proxy uses this to wait for a backend without holding a thread). None (the default) means “use execute”. Wrappers return Some only when they add no synchronous work of their own.

impl<S: Clone> Clone for AsyncAppWithState<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.