Struct roa_core::SyncContext

pub struct SyncContext<S> {
    pub exec: Executor,
    pub remote_addr: SocketAddr,
    // some fields omitted
}

Sync parts of Context.

Fields

exec: Executor

Application level runtime.

remote_addr: SocketAddr

Socket addr of last client or proxy.

Methods

impl<S> 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: Clone> Clone for SyncContext<S>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Deref for SyncContext<S>

type Target = S

The resulting type after dereferencing.

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

Dereferences the value.

impl<S> DerefMut for SyncContext<S>

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

Mutably dereferences the value.