feat(http): implement Default for Body

seanmonstar · seanmonstar · commit 6faa653f0dfa · 2017-05-01T12:29:06.000-07:00
diff --git a/src/http/body.rs b/src/http/body.rs
@@ -13,76 +13,95 @@ pub struct Body(TokioBody);
 
 impl Body {
     /// Return an empty body stream
+    #[inline]
     pub fn empty() -> Body {
         Body(TokioBody::empty())
     }
 
     /// Return a body stream with an associated sender half
+    #[inline]
     pub fn pair() -> (mpsc::Sender<Result<Chunk, ::Error>>, Body) {
         let (tx, rx) = TokioBody::pair();
         let rx = Body(rx);
         (tx, rx)
     }
 }
 
+impl Default for Body {
+    #[inline]
+    fn default() -> Body {
+        Body::empty()
+    }
+}
+
 impl Stream for Body {
     type Item = Chunk;
     type Error = ::Error;
 
+    #[inline]
     fn poll(&mut self) -> Poll<Option<Chunk>, ::Error> {
         self.0.poll()
     }
 }
 
 impl From<Body> for tokio_proto::streaming::Body<Chunk, ::Error> {
+    #[inline]
     fn from(b: Body) -> tokio_proto::streaming::Body<Chunk, ::Error> {
         b.0
     }
 }
 
 impl From<tokio_proto::streaming::Body<Chunk, ::Error>> for Body {
+    #[inline]
     fn from(tokio_body: tokio_proto::streaming::Body<Chunk, ::Error>) -> Body {
         Body(tokio_body)
     }
 }
 
 impl From<mpsc::Receiver<Result<Chunk, ::Error>>> for Body {
+    #[inline]
     fn from(src: mpsc::Receiver<Result<Chunk, ::Error>>) -> Body {
         Body(src.into())
     }
 }
 
 impl From<Chunk> for Body {
+    #[inline]
     fn from (chunk: Chunk) -> Body {
         Body(TokioBody::from(chunk))
     }
 }
 
 impl From<Bytes> for Body {
+    #[inline]
     fn from (bytes: Bytes) -> Body {
         Body(TokioBody::from(Chunk::from(bytes)))
     }
 }
 
 impl From<Vec<u8>> for Body {
+    #[inline]
     fn from (vec: Vec<u8>) -> Body {
         Body(TokioBody::from(Chunk::from(vec)))
     }
 }
 
 impl From<&'static [u8]> for Body {
+    #[inline]
     fn from (slice: &'static [u8]) -> Body {
         Body(TokioBody::from(Chunk::from(slice)))
     }
 }
 
 impl From<String> for Body {
+    #[inline]
     fn from (s: String) -> Body {
         Body(TokioBody::from(Chunk::from(s.into_bytes())))
     }
 }
 
 impl From<&'static str> for Body {
+    #[inline]
     fn from (slice: &'static str) -> Body {
         Body(TokioBody::from(Chunk::from(slice.as_bytes())))
     }
@@ -107,7 +126,7 @@ fn test_body_stream_concat() {
         tx.send(Ok("world".into())).wait().unwrap();
     });
 
-    let total = body.concat().wait().unwrap();
+    let total = body.concat2().wait().unwrap();
     assert_eq!(total.as_ref(), b"hello world");
 
 }

Original file line number	Diff line number	Diff line change
`@@ -13,76 +13,95 @@ pub struct Body(TokioBody);`
`13`	`13`
`14`	`14`	`impl Body {`
`15`	`15`	`/// Return an empty body stream`
	`16`	`+ #[inline]`
`16`	`17`	`pub fn empty() -> Body {`
`17`	`18`	`Body(TokioBody::empty())`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`/// Return a body stream with an associated sender half`
	`22`	`+ #[inline]`
`21`	`23`	`pub fn pair() -> (mpsc::Sender<Result<Chunk, ::Error>>, Body) {`
`22`	`24`	`let (tx, rx) = TokioBody::pair();`
`23`	`25`	`let rx = Body(rx);`
`24`	`26`	`(tx, rx)`
`25`	`27`	`}`
`26`	`28`	`}`
`27`	`29`
	`30`	`+impl Default for Body {`
	`31`	`+ #[inline]`
	`32`	`+ fn default() -> Body {`
	`33`	`+ Body::empty()`
	`34`	`+ }`
	`35`	`+}`
	`36`	`+`
`28`	`37`	`impl Stream for Body {`
`29`	`38`	`type Item = Chunk;`
`30`	`39`	`type Error = ::Error;`
`31`	`40`
	`41`	`+ #[inline]`
`32`	`42`	`fn poll(&mut self) -> Poll<Option<Chunk>, ::Error> {`
`33`	`43`	`self.0.poll()`
`34`	`44`	`}`
`35`	`45`	`}`
`36`	`46`
`37`	`47`	`impl From<Body> for tokio_proto::streaming::Body<Chunk, ::Error> {`
	`48`	`+ #[inline]`
`38`	`49`	`fn from(b: Body) -> tokio_proto::streaming::Body<Chunk, ::Error> {`
`39`	`50`	`b.0`
`40`	`51`	`}`
`41`	`52`	`}`
`42`	`53`
`43`	`54`	`impl From<tokio_proto::streaming::Body<Chunk, ::Error>> for Body {`
	`55`	`+ #[inline]`
`44`	`56`	`fn from(tokio_body: tokio_proto::streaming::Body<Chunk, ::Error>) -> Body {`
`45`	`57`	`Body(tokio_body)`
`46`	`58`	`}`
`47`	`59`	`}`
`48`	`60`
`49`	`61`	`impl From<mpsc::Receiver<Result<Chunk, ::Error>>> for Body {`
	`62`	`+ #[inline]`
`50`	`63`	`fn from(src: mpsc::Receiver<Result<Chunk, ::Error>>) -> Body {`
`51`	`64`	`Body(src.into())`
`52`	`65`	`}`
`53`	`66`	`}`
`54`	`67`
`55`	`68`	`impl From<Chunk> for Body {`
	`69`	`+ #[inline]`
`56`	`70`	`fn from (chunk: Chunk) -> Body {`
`57`	`71`	`Body(TokioBody::from(chunk))`
`58`	`72`	`}`
`59`	`73`	`}`
`60`	`74`
`61`	`75`	`impl From<Bytes> for Body {`
	`76`	`+ #[inline]`
`62`	`77`	`fn from (bytes: Bytes) -> Body {`
`63`	`78`	`Body(TokioBody::from(Chunk::from(bytes)))`
`64`	`79`	`}`
`65`	`80`	`}`
`66`	`81`
`67`	`82`	`impl From<Vec<u8>> for Body {`
	`83`	`+ #[inline]`
`68`	`84`	`fn from (vec: Vec<u8>) -> Body {`
`69`	`85`	`Body(TokioBody::from(Chunk::from(vec)))`
`70`	`86`	`}`
`71`	`87`	`}`
`72`	`88`
`73`	`89`	`impl From<&'static [u8]> for Body {`
	`90`	`+ #[inline]`
`74`	`91`	`fn from (slice: &'static [u8]) -> Body {`
`75`	`92`	`Body(TokioBody::from(Chunk::from(slice)))`
`76`	`93`	`}`
`77`	`94`	`}`
`78`	`95`
`79`	`96`	`impl From<String> for Body {`
	`97`	`+ #[inline]`
`80`	`98`	`fn from (s: String) -> Body {`
`81`	`99`	`Body(TokioBody::from(Chunk::from(s.into_bytes())))`
`82`	`100`	`}`
`83`	`101`	`}`
`84`	`102`
`85`	`103`	`impl From<&'static str> for Body {`
	`104`	`+ #[inline]`
`86`	`105`	`fn from (slice: &'static str) -> Body {`
`87`	`106`	`Body(TokioBody::from(Chunk::from(slice.as_bytes())))`
`88`	`107`	`}`
`@@ -107,7 +126,7 @@ fn test_body_stream_concat() {`
`107`	`126`	`tx.send(Ok("world".into())).wait().unwrap();`
`108`	`127`	`});`
`109`	`128`
`110`		`- let total = body.concat().wait().unwrap();`
	`129`	`+ let total = body.concat2().wait().unwrap();`
`111`	`130`	`assert_eq!(total.as_ref(), b"hello world");`
`112`	`131`
`113`	`132`	`}`