Struct AppWithState 

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

An Application that combines user-defined state-aware routes with the built-in App controller chain as a fallback.

Routes are matched in registration order. The first match wins; unmatched requests are forwarded to App (static files, health probes, etc.).

Implementations

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

pub fn new(state: S) -> Self

Create a new AppWithState wrapping state.

state is stored behind an Arc so it can be shared across threads without cloning. Register routes with the builder methods.

pub fn state(&self) -> &S

Return a reference to the shared state.

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

where F: Fn(&Request, &PathParams, &ConnectionInfo, &S) -> Response + Send + Sync + 'static,

Register a GET handler for pattern.

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

where F: Fn(&Request, &PathParams, &ConnectionInfo, &S) -> Response + Send + Sync + 'static,

Register a POST handler for pattern.

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

where F: Fn(&Request, &PathParams, &ConnectionInfo, &S) -> Response + Send + Sync + 'static,

Register a PUT handler for pattern.

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

where F: Fn(&Request, &PathParams, &ConnectionInfo, &S) -> Response + Send + Sync + 'static,

Register a PATCH handler for pattern.

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

where F: Fn(&Request, &PathParams, &ConnectionInfo, &S) -> Response + Send + Sync + 'static,

Register a DELETE handler for pattern.

pub fn wrap<M: Middleware + 'static>( self, layer: M, ) -> WithMiddleware<AppWithState<S>>

Wrap this application in a middleware layer.

Enables fluent composition:

use rust_web_server::app::App;
use rust_web_server::middleware::RateLimitLayer;
use rust_web_server::response::Response;

let app = App::with_state(())
    .get("/ping", |_, _, _, _| Response::new())
    .wrap(RateLimitLayer);

Trait Implementations

impl<S: Send + Sync + 'static> Application for AppWithState<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.