include payload into request

examples/basic.rs

@@ -7,14 +7,14 @@ extern crate env_logger;
 extern crate futures;
 
 use actix_web::*;
-use actix_web::error::Result;
+use actix_web::error::{Error, Result};
 use actix_web::middlewares::RequestSession;
 use futures::stream::{once, Once};
 
 /// somple handle
-fn index(req: &mut HttpRequest, mut _payload: Payload, state: &()) -> Result<HttpResponse> {
+fn index(req: &mut HttpRequest, state: &()) -> Result<HttpResponse> {
     println!("{:?}", req);
-    if let Ok(ch) = _payload.readany() {
+    if let Ok(ch) = req.payload_mut().readany() {
         if let futures::Async::Ready(Some(d)) = ch {
             println!("{}", String::from_utf8_lossy(d.0.as_ref()));
         }
@@ -32,8 +32,7 @@ fn index(req: &mut HttpRequest, mut _payload: Payload, state: &()) -> Result<Htt
 }
 
 /// somple handle
-fn index_async(req: &mut HttpRequest, _payload: Payload, state: &())
-               -> Once<actix_web::Frame, actix_web::error::Error>
+fn index_async(req: &mut HttpRequest, state: &()) -> Once<actix_web::Frame, Error>
 {
     println!("{:?}", req);
 
@@ -45,7 +44,7 @@ fn index_async(req: &mut HttpRequest, _payload: Payload, state: &())
 }
 
 /// handle with path parameters like `/user/{name}/`
-fn with_param(req: &mut HttpRequest, _payload: Payload, state: &()) -> Result<HttpResponse>
+fn with_param(req: &mut HttpRequest, state: &()) -> Result<HttpResponse>
 {
     println!("{:?}", req);
 
@@ -76,7 +75,7 @@ fn main() {
             // async handler
             .resource("/async/{name}", |r| r.async(Method::GET, index_async))
             // redirect
-            .resource("/", |r| r.handler(Method::GET, |req, _, _| {
+            .resource("/", |r| r.handler(Method::GET, |req, _| {
                 println!("{:?}", req);
 
                 Ok(httpcodes::HTTPFound

examples/state.rs

@@ -15,7 +15,7 @@ struct AppState {
 }
 
 /// somple handle
-fn index(req: &mut HttpRequest, _: Payload, state: &AppState) -> HttpResponse {
+fn index(req: &mut HttpRequest, state: &AppState) -> HttpResponse {
     println!("{:?}", req);
     state.counter.set(state.counter.get() + 1);
     httpcodes::HTTPOk.with_body(
@@ -36,12 +36,11 @@ impl Route for MyWebSocket {
     /// Shared application state
     type State = AppState;
 
-    fn request(req: &mut HttpRequest,
-               payload: Payload, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
+    fn request(req: &mut HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
     {
         let resp = ws::handshake(req)?;
         ctx.start(resp);
-        ctx.add_stream(ws::WsStream::new(payload));
+        ctx.add_stream(ws::WsStream::new(req));
         Reply::async(MyWebSocket{counter: 0})
     }
 }

examples/websocket.rs

@@ -22,15 +22,14 @@ impl Actor for MyWebSocket {
 impl Route for MyWebSocket {
     type State = ();
 
-    fn request(req: &mut HttpRequest,
-               payload: Payload, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
+    fn request(req: &mut HttpRequest, ctx: &mut HttpContext<Self>) -> RouteResult<Self>
     {
         // websocket handshake
         let resp = ws::handshake(req)?;
         // send HttpResponse back to peer
         ctx.start(resp);
         // convert bytes stream to a stream of `ws::Message` and register it
-        ctx.add_stream(ws::WsStream::new(payload));
+        ctx.add_stream(ws::WsStream::new(req));
         Reply::async(MyWebSocket)
     }
 }