reep 0.2.0

[deprecated] REsource EndPoint (REEP): Generic Iron Endpoint for RESTlike Resource Access
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

use std::sync::Arc;
use std::any::Any;
use iron::{headers, status, Request, Response, IronResult, method};
use iron::middleware::{BeforeMiddleware, Handler};
use middleware::{ActualParserMiddleware, IdParser};
use types::{Id, ParserMiddleware};


pub struct Parsers<OpP: ParserMiddleware, BoP: ParserMiddleware> {
    //TODO roll out traits...
    pub id_parser: Arc<Box<BeforeMiddleware>>,
    pub option_parser: Arc<ActualParserMiddleware<OpP>>,
    pub body_parser: Arc<ActualParserMiddleware<BoP>>
}

impl<OpP, BoP> Parsers<OpP, BoP>
    where OpP: ParserMiddleware, BoP: ParserMiddleware
{
    pub fn new<Idt: Send+Sync+Any>(option_parser: OpP, body_parser: BoP) -> Self
        where Idt: Id {

        Parsers {
            id_parser: Arc::new(Box::new(IdParser::<Idt>::new())),
            option_parser: Arc::new(ActualParserMiddleware::new(option_parser)),
            body_parser: Arc::new(ActualParserMiddleware::new(body_parser))
        }
    }
}


pub struct OptionHandler(headers::Allow);

impl OptionHandler {
    pub fn new(methods: Vec<method::Method>) -> OptionHandler {
        OptionHandler(headers::Allow(methods))
    }
}

impl Handler for OptionHandler {
    fn handle(&self, _: &mut Request) -> IronResult<Response> {
        let mut response = Response::with(status::Ok);
        response.headers.set::<headers::Allow>(self.0.clone());
        Ok(response)
    }
}