titan 0.4.2

Titan is a web-framework, SSR engine with css-in-rust support, http server and http router.
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use std::{future::Future, marker::PhantomData, pin::Pin, task::Poll};

use titan_core::{FromRequest, Handler, Respondable};
use titan_http::{Request, Response};

pub struct Route<T, Args>
where
  T: Handler<Args>,
  Args: FromRequest,
{
  handler: T,
  _a: PhantomData<Args>,
}

impl<T, A> Clone for Route<T, A>
where
  T: Handler<A> + Clone,
  A: FromRequest,
{
  fn clone(&self) -> Self {
    Self { _a: PhantomData, handler: self.handler.clone() }
  }
}

impl<T, Args> Route<T, Args>
where
  T: Handler<Args>,
  Args: FromRequest + Send + 'static,
{
  pub fn new(handler: T) -> Self {
    Self { handler, _a: PhantomData }
  }
}

impl<T, Args> titan_core::Service<Request> for Route<T, Args>
where
  T: Handler<Args> + Sync + Clone + 'static,
  T::Future: Future<Output = T::Output> + Send + 'static,
  T::Output: Respondable,
  Args: FromRequest + Send + Sync + 'static,
  Args::Error: Send,
{
  type Response = Response;
  type Error = Response;
  type Future =
    Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;

  fn poll_ready(
    &mut self,
    _cx: &mut std::task::Context<'_>,
  ) -> Poll<Result<(), Self::Error>> {
    Poll::Ready(Ok(()))
  }

  fn call(&mut self, req: Request) -> Self::Future {
    let handler = self.handler.clone();
    Box::pin(async move {
      let response: Result<Args, <Args as FromRequest>::Error> =
        FromRequest::from_request(req);
      match response {
        Ok(value) => {
          let result = Handler::call(&handler, value).await;
          Ok(result.respond())
        }
        Err(_err) => Err(_err.respond()),
      }
    })
  }
}