Struct Read

pub struct Read<P: Key> { /* private fields */ }

Middleware for data that persists between Requests with read-only capabilities.

The data is stored behind an Arc, so multiple threads can have concurrent, non-blocking access.

Read can be linked as BeforeMiddleware to add data to the Request extensions and it can be linked as an AfterMiddleware to add data to the Response extensions.

Read also implements Plugin, so the data stored within can be accessed through request.get::<Read<P>>() as an Arc<P::Value>.

Implementations

impl<P: Key> Read<P>

where P::Value: Send + Sync,

pub fn both<T>(start: T) -> (Read<P>, Read<P>)

where T: PersistentInto<Arc<P::Value>>,

Construct a new pair of Read that can be passed directly to Chain::link.

The data is initialized with the passed-in value.

Examples found in repository

examples/variable_passing.rs (line 28)

fn main() {
    // This can be passed from command line arguments for example.
    let log_path = String::from("/path/to/a/log/file.log");
    let mut chain = Chain::new(serve_hits);
    chain.link(Read::<Log>::both(log_path));
    Iron::new(chain).http("localhost:3000").unwrap();
}

pub fn one<T>(start: T) -> Read<P>

where T: PersistentInto<Arc<P::Value>>,

Construct a new Read that can be passed directly to Chain::link_before or Chain::link_after.

The data is initialized with the passed-in value.

Trait Implementations

impl<P: Key> AfterMiddleware for Read<P>

where P::Value: Send + Sync,

fn after(&self, _: &mut Request<'_, '_>, res: Response) -> IronResult<Response>

Do whatever post-processing this middleware should do.

fn catch( &self, _: &mut Request<'_, '_>, err: IronError, ) -> Result<Response, IronError>

Respond to an error thrown by previous AfterMiddleware, the Handler, or a BeforeMiddleware.

impl<P: Key> BeforeMiddleware for Read<P>

where P::Value: Send + Sync,

fn before(&self, req: &mut Request<'_, '_>) -> IronResult<()>

Do whatever work this middleware should do with a Request object.

fn catch( &self, _: &mut Request<'_, '_>, err: IronError, ) -> Result<(), IronError>

Respond to an error thrown by a previous BeforeMiddleware.

impl<P: Key> Clone for Read<P>

where P::Value: Send + Sync,

fn clone(&self) -> Read<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Key> Key for Read<P>

where P::Value: 'static,

type Value = Arc<<P as Key>::Value>

The value type associated with this key type.

impl<'a, 'b, P: Key> Plugin<Request<'a, 'b>> for Read<P>

where P::Value: Send + Sync,

type Error = PersistentError

The error type associated with this plugin.

fn eval(req: &mut Request<'a, 'b>) -> Result<Arc<P::Value>, PersistentError>

Create the plugin from an instance of the extended type.