Struct roa_core::Context

pub struct Context<S>(_);

A structure to share request, response and other data between middlewares.

Type of the first parameter in a middleware.

Example

use roa_core::App;
use log::info;
use async_std::fs::File;

let mut app = App::new(());
app.gate_fn(|ctx, next| async move {
    info!("{} {}", ctx.method(), ctx.uri());
    next.await
});
app.end(|mut ctx| async move {
    ctx.resp_mut().write(File::open("assets/welcome.html").await?);
    Ok(())
});

Methods

impl<S> Context<S>

pub fn req(&self) -> &Request

Get an immutable reference of request.

Example

use roa_core::App;
use roa_core::http::Method;

let mut app = App::new(());
app.end(|ctx| async move {
    assert_eq!(Method::GET, ctx.req().method);
    Ok(())
});

pub fn resp(&self) -> &Response

Get an immutable reference of response.

Example

use roa_core::App;
use roa_core::http::StatusCode;

let mut app = App::new(());
app.end(|ctx| async move {
    assert_eq!(StatusCode::OK, ctx.resp().status);
    Ok(())
});

pub fn req_mut(&mut self) -> &mut Request

Get a mutable reference of request.

Example

use roa_core::App;
use roa_core::http::Method;

let mut app = App::new(());
app.gate_fn(|mut ctx, next| async move {
    ctx.req_mut().method = Method::POST;
    next.await
});
app.end(|ctx| async move {
    assert_eq!(Method::POST, ctx.req().method);
    Ok(())
});

pub fn resp_mut(&mut self) -> &mut Response

Get a mutable reference of response.

Example

use roa_core::App;

let mut app = App::new(());
app.end(|mut ctx| async move {
    ctx.resp_mut().write(b"Hello, World!".as_ref());
    Ok(())
});

pub fn uri(&self) -> &Uri

Clone URI.

Example

use roa_core::App;

let mut app = App::new(());
app.end(|ctx| async move {
    assert_eq!("/", ctx.uri().to_string());
    Ok(())
});

pub fn method(&self) -> &Method

Clone request::method.

Example

use roa_core::App;
use http::Method;

let mut app = App::new(());
app.end(|ctx| async move {
    assert_eq!(Method::GET, ctx.method());
    Ok(())
});

pub fn header(
    &self,
    name: impl AsHeaderName
) -> Option<Result<&str, ToStrError>>

Search for a header value and try to get its string copy.

Example

use roa_core::App;
use roa_core::http::{StatusCode, header};

let mut app = App::new(());
app.end(|ctx| async move {
    assert_eq!(
        "text/plain",
        ctx.header(&header::CONTENT_TYPE).unwrap().unwrap()
    );
    Ok(())
});

pub fn status(&self) -> StatusCode

Clone response::status.

Example

use roa_core::{App, http::StatusCode};

let mut app = App::new(());
app.end(|ctx| async move {
    assert_eq!(StatusCode::OK, ctx.status());
    Ok(())
});

pub fn version(&self) -> Version

Clone request::version.

Example

use roa_core::App;
use roa_core::http::{StatusCode, Version};

let mut app = App::new(());
app.end(|ctx| async move {
    assert_eq!(Version::HTTP_11, ctx.version());
    Ok(())
});

Methods from Deref<Target = SyncContext<S>>

pub fn store_scoped<'a, SC, T>(
    &mut self,
    _scope: SC,
    name: &'a str,
    value: T
) -> Option<Variable<'a, T>> where
    SC: Any,
    T: Any + Send + Sync, 

Store key-value pair in specific scope.

Example

use roa_core::App;
use roa_core::http::{StatusCode, Method};

struct Scope;
struct AnotherScope;

let mut app = App::new(());
app.gate_fn(|mut ctx, next| async move {
    ctx.store_scoped(Scope, "id", "1".to_string());
    next.await
});
app.end(|ctx| async move {
    assert_eq!(1, ctx.load_scoped::<Scope, String>("id").unwrap().parse::<i32>()?);
    assert!(ctx.load_scoped::<AnotherScope, String>("id").is_none());
    Ok(())
});

pub fn store<'a, T>(
    &mut self,
    name: &'a str,
    value: T
) -> Option<Variable<'a, T>> where
    T: Any + Send + Sync, 

Store key-value pair in public scope.

Example

use roa_core::App;
use roa_core::http::{StatusCode, Method};

let mut app = App::new(());
app.gate_fn(|mut ctx, next| async move {
    ctx.store("id", "1".to_string());
    next.await
});
app.end(|ctx| async move {
    assert_eq!(1, ctx.load::<String>("id").unwrap().parse::<i32>()?);
    Ok(())
});

pub fn load_scoped<'a, SC, T>(&self, name: &'a str) -> Option<Variable<'a, T>> where
    SC: Any,
    T: Any + Send + Sync, 

Search for value by key in specific scope.

Example

use roa_core::App;

struct Scope;

let mut app = App::new(());
app.gate_fn(|mut ctx, next| async move {
    ctx.store_scoped(Scope, "id", "1".to_owned());
    next.await
});
app.end(|ctx| async move {
    assert_eq!(1, ctx.load_scoped::<Scope, String>("id").unwrap().parse::<i32>()?);
    Ok(())
});

pub fn load<'a, T>(&self, name: &'a str) -> Option<Variable<'a, T>> where
    T: Any + Send + Sync, 

Search for value by key in public scope.

Example

use roa_core::App;

let mut app = App::new(());
app.gate_fn(|mut ctx, next| async move {
    ctx.store("id", "1".to_string());
    next.await
});
app.end(|ctx| async move {
    assert_eq!(1, ctx.load::<String>("id").unwrap().parse::<i32>()?);
    Ok(())
});

Trait Implementations

impl<S> Deref for Context<S>

type Target = SyncContext<S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S> DerefMut for Context<S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.