use std::rc::Rc; use std::marker::PhantomData; use actix::Actor; use bytes::Bytes; use futures::unsync::mpsc::Receiver; use task::Task; use context::HttpContext; use resource::HttpMessage; use httpmessage::{HttpRequest, HttpResponse, IntoHttpResponse}; /// Stream of `PayloadItem`'s pub type Payload = Receiver; /// `PayloadItem` represents one payload item #[derive(Debug)] pub enum PayloadItem { /// Indicates end of payload stream Eof, /// Chunk of bytes Chunk(Bytes) } impl PayloadItem { /// Is item an eof pub fn is_eof(&self) -> bool { match *self { PayloadItem::Eof => true, _ => false, } } /// Is item a chunk pub fn is_chunk(&self) -> bool { !self.is_eof() } } #[doc(hidden)] #[derive(Debug)] #[cfg_attr(feature="cargo-clippy", allow(large_enum_variant))] pub enum Frame { Message(HttpResponse), Payload(Option), } pub trait RouteHandler: 'static { fn handle(&self, req: HttpRequest, payload: Option, state: Rc) -> Task; } /// Actors with ability to handle http requests pub trait Route: Actor> { type State; fn request(req: HttpRequest, payload: Option, ctx: &mut HttpContext) -> HttpMessage; fn factory() -> RouteFactory { RouteFactory(PhantomData) } /// Create async response fn stream(act: Self) -> HttpMessage { HttpMessage::stream(act) } /// Create response fn reply(req: HttpRequest, msg: I) -> HttpMessage where I: IntoHttpResponse { HttpMessage::reply(req, msg) } } pub struct RouteFactory, S>(PhantomData); impl RouteHandler for RouteFactory where A: Route, S: 'static { fn handle(&self, req: HttpRequest, payload: Option, state: Rc) -> Task { let mut ctx = HttpContext::new(state); A::request(req, payload, &mut ctx).into(ctx) } }