From ed491655dd0872016ee61788295df2c48525c34b Mon Sep 17 00:00:00 2001
From: Jonathan Reem <jonathan.reem@gmail.com>
Date: Tue, 9 Sep 2014 16:51:32 -0700
Subject: [PATCH] Use dynamic dispatch for client Request and Response through
 Box<NetworkStream>

Also adds a convenience `abstract` method to NetworkStream for creating
Box<NetworkStream + Send> from a NetworkStream.
---
 src/client/request.rs  | 16 ++++++++--------
 src/client/response.rs | 10 +++++-----
 src/net.rs             | 16 ++++++++++++++++
 src/server/request.rs  |  2 +-
 src/server/response.rs |  2 +-
 5 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/src/client/request.rs b/src/client/request.rs
index cc5e53f2..c48e5196 100644
--- a/src/client/request.rs
+++ b/src/client/request.rs
@@ -14,7 +14,7 @@ use super::{Response};
 
 
 /// A client request to a remote server.
-pub struct Request<S = HttpStream> {
+pub struct Request {
     /// The method of this request.
     pub method: method::Method,
     /// The headers that will be sent with this request.
@@ -24,13 +24,13 @@ pub struct Request<S = HttpStream> {
     /// The HTTP version of this request.
     pub version: version::HttpVersion,
     headers_written: bool,
-    body: BufferedWriter<S>,
+    body: BufferedWriter<Box<NetworkStream + Send>>,
 }
 
-impl<S: NetworkStream> Request<S> {
+impl Request {
 
     /// Create a new client request.
-    pub fn new(method: method::Method, url: Url) -> HttpResult<Request<S>> {
+    pub fn new(method: method::Method, url: Url) -> HttpResult<Request> {
         debug!("{} {}", method, url);
         let host = match url.serialize_host() {
             Some(host) => host,
@@ -43,8 +43,8 @@ impl<S: NetworkStream> Request<S> {
         };
         debug!("port={}", port);
 
-        let stream = try_io!(NetworkStream::connect(host.as_slice(), port));
-        let stream = BufferedWriter::new(stream);
+        let stream: HttpStream = try_io!(NetworkStream::connect(host.as_slice(), port));
+        let stream = BufferedWriter::new(stream.abstract());
         let mut headers = Headers::new();
         headers.set(Host(host));
         Ok(Request {
@@ -82,7 +82,7 @@ impl<S: NetworkStream> Request<S> {
     /// Completes writing the request, and returns a response to read from.
     ///
     /// Consumes the Request.
-    pub fn send(mut self) -> HttpResult<Response<S>> {
+    pub fn send(mut self) -> HttpResult<Response> {
         try_io!(self.flush());
         let raw = self.body.unwrap();
         Response::new(raw)
@@ -90,7 +90,7 @@ impl<S: NetworkStream> Request<S> {
 }
 
 
-impl<S: NetworkStream> Writer for Request<S> {
+impl Writer for Request {
     fn write(&mut self, msg: &[u8]) -> IoResult<()> {
         if !self.headers_written {
             try!(self.write_head());
diff --git a/src/client/response.rs b/src/client/response.rs
index 2e6f5eed..ef05cf40 100644
--- a/src/client/response.rs
+++ b/src/client/response.rs
@@ -18,14 +18,14 @@ pub struct Response<S = HttpStream> {
     pub headers: header::Headers,
     /// The HTTP version of this response from the server.
     pub version: version::HttpVersion,
-    body: HttpReader<BufferedReader<S>>,
+    body: HttpReader<BufferedReader<Box<NetworkStream + Send>>>,
 }
 
-impl<S: NetworkStream> Response<S> {
+impl Response {
 
     /// Creates a new response from a server.
-    pub fn new(stream: S) -> HttpResult<Response<S>> {
-        let mut stream = BufferedReader::new(stream);
+    pub fn new(stream: Box<NetworkStream + Send>) -> HttpResult<Response> {
+        let mut stream = BufferedReader::new(stream.abstract());
         let (version, status) = try!(read_status_line(&mut stream));
         let mut headers = try!(header::Headers::from_raw(&mut stream));
 
@@ -67,7 +67,7 @@ impl<S: NetworkStream> Response<S> {
     }
 }
 
-impl<S: NetworkStream> Reader for Response<S> {
+impl Reader for Response {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
         self.body.read(buf)
diff --git a/src/net.rs b/src/net.rs
index 943ba0a6..2a3f5796 100644
--- a/src/net.rs
+++ b/src/net.rs
@@ -28,6 +28,22 @@ pub trait NetworkStream: Stream + Clone + Send {
 
     /// Connect to a remote address.
     fn connect(host: &str, port: Port) -> IoResult<Self>;
+
+    /// Turn this into an appropriately typed trait object.
+    #[inline]
+    fn abstract(self) -> Box<NetworkStream + Send> {
+        box self as Box<NetworkStream + Send>
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    // Hack to work around lack of Clone impl for Box<Clone>
+    fn clone_box(&self) -> Box<NetworkStream + Send> { self.clone().abstract() }
+}
+
+impl Clone for Box<NetworkStream + Send> {
+    #[inline]
+    fn clone(&self) -> Box<NetworkStream + Send> { self.clone_box() }
 }
 
 impl Reader for Box<NetworkStream + Send> {
diff --git a/src/server/request.rs b/src/server/request.rs
index 81570d67..89071afb 100644
--- a/src/server/request.rs
+++ b/src/server/request.rs
@@ -37,7 +37,7 @@ impl Request {
     /// immediately useful.
     pub fn new<S: NetworkStream>(mut stream: S) -> HttpResult<Request> {
         let remote_addr = try_io!(stream.peer_name());
-        let mut stream = BufferedReader::new(box stream as Box<NetworkStream + Send>);
+        let mut stream = BufferedReader::new(stream.abstract());
         let (method, uri, version) = try!(read_request_line(&mut stream));
         let mut headers = try!(Headers::from_raw(&mut stream));
 
diff --git a/src/server/response.rs b/src/server/response.rs
index 165979fb..155138eb 100644
--- a/src/server/response.rs
+++ b/src/server/response.rs
@@ -66,7 +66,7 @@ impl Response<Fresh> {
             status: status::Ok,
             version: version::Http11,
             headers: header::Headers::new(),
-            body: BufferedWriter::new(box stream as Box<NetworkStream + Send>)
+            body: BufferedWriter::new(stream.abstract())
         }
     }