changed stream trait to impl Read and Write, not contain

Author: illegalprime

src/client/builder.rs

@@ -1,5 +1,4 @@
 use std::borrow::Cow;
-use std::io::Write;
 use std::net::TcpStream;
 pub use url::{Url, ParseError};
 use url::Position;
@@ -12,12 +11,11 @@ use unicase::UniCase;
 #[cfg(feature="ssl")]
 use openssl::ssl::{SslMethod, SslStream, SslConnector, SslConnectorBuilder};
 #[cfg(feature="ssl")]
-use stream::BoxedNetworkStream;
 use header::extensions::Extension;
 use header::{WebSocketAccept, WebSocketKey, WebSocketVersion, WebSocketProtocol,
              WebSocketExtensions, Origin};
 use result::{WSUrlErrorKind, WebSocketResult, WebSocketError};
-use stream::Stream;
+use stream::{Stream, NetworkStream};
 use super::Client;
 
 /// Build clients with a builder-style API
@@ -182,13 +180,14 @@ impl<'u> ClientBuilder<'u> {
 	pub fn connect(
 		&mut self,
 		ssl_config: Option<SslConnector>,
-	) -> WebSocketResult<Client<BoxedNetworkStream>> {
+	) -> WebSocketResult<Client<Box<NetworkStream>>> {
 		let tcp_stream = try!(self.establish_tcp(None));
 
-		let boxed_stream = if self.url.scheme() == "wss" {
-			BoxedNetworkStream(Box::new(try!(self.wrap_ssl(tcp_stream, ssl_config))))
+		let boxed_stream: Box<NetworkStream> = if
+			self.url.scheme() == "wss" {
+			Box::new(try!(self.wrap_ssl(tcp_stream, ssl_config)))
 		} else {
-			BoxedNetworkStream(Box::new(tcp_stream))
+			Box::new(tcp_stream)
 		};
 
 		self.connect_on(boxed_stream)
@@ -248,12 +247,12 @@ impl<'u> ClientBuilder<'u> {
 		}
 
 		// send request
-		try!(write!(stream.writer(), "GET {} {}\r\n", resource, self.version));
-		try!(write!(stream.writer(), "{}\r\n", self.headers));
+		try!(write!(stream, "GET {} {}\r\n", resource, self.version));
+		try!(write!(stream, "{}\r\n", self.headers));
 
 		// wait for a response
 		// TODO: some extra data might get lost with this reader, try to avoid #72
-		let response = try!(parse_response(&mut BufReader::new(stream.reader())));
+		let response = try!(parse_response(&mut BufReader::new(&mut stream)));
 		let status = StatusCode::from_u16(response.subject.0);
 
 		// validate

src/client/mod.rs

@@ -128,33 +128,33 @@ impl<S> Client<S>
 	pub fn send_dataframe<D>(&mut self, dataframe: &D) -> WebSocketResult<()>
 		where D: DataFrameable
 	{
-		self.sender.send_dataframe(self.stream.writer(), dataframe)
+		self.sender.send_dataframe(&mut self.stream, dataframe)
 	}
 
 	/// Sends a single message to the remote endpoint.
 	pub fn send_message<'m, M, D>(&mut self, message: &'m M) -> WebSocketResult<()>
 		where M: ws::Message<'m, D>,
 		      D: DataFrameable
 	{
-		self.sender.send_message(self.stream.writer(), message)
+		self.sender.send_message(&mut self.stream, message)
 	}
 
 	/// Reads a single data frame from the remote endpoint.
 	pub fn recv_dataframe(&mut self) -> WebSocketResult<DataFrame> {
-		self.receiver.recv_dataframe(self.stream.reader())
+		self.receiver.recv_dataframe(&mut self.stream)
 	}
 
 	/// Returns an iterator over incoming data frames.
-	pub fn incoming_dataframes<'a>(&'a mut self) -> DataFrameIterator<'a, Receiver, S::Reader> {
-		self.receiver.incoming_dataframes(self.stream.reader())
+	pub fn incoming_dataframes<'a>(&'a mut self) -> DataFrameIterator<'a, Receiver, S> {
+		self.receiver.incoming_dataframes(&mut self.stream)
 	}
 
 	/// Reads a single message from this receiver.
 	pub fn recv_message<'m, M, I>(&mut self) -> WebSocketResult<M>
 		where M: ws::Message<'m, DataFrame, DataFrameIterator = I>,
 		      I: Iterator<Item = DataFrame>
 	{
-		self.receiver.recv_message(self.stream.reader())
+		self.receiver.recv_message(&mut self.stream)
 	}
 
 	pub fn headers(&self) -> &Headers {
@@ -229,12 +229,11 @@ impl<S> Client<S>
 	///}
 	///# }
 	///```
-	pub fn incoming_messages<'a, M, D>(&'a mut self,)
-		-> MessageIterator<'a, Receiver, D, M, S::Reader>
+	pub fn incoming_messages<'a, M, D>(&'a mut self) -> MessageIterator<'a, Receiver, D, M, S>
 		where M: ws::Message<'a, D>,
 		      D: DataFrameable
 	{
-		self.receiver.incoming_messages(self.stream.reader())
+		self.receiver.incoming_messages(&mut self.stream)
 	}
 }
 

src/server/upgrade/hyper.rs

@@ -27,6 +27,8 @@ impl<'a, 'b> IntoWs for HyperRequest<'a, 'b> {
 
 		let (_, method, headers, uri, version, reader) =
 			self.0.deconstruct();
+
+		// TODO: some extra data might get lost with this reader, try to avoid #72
 		let stream = reader.into_inner().get_mut();
 
 		Ok(WsUpgrade {

src/server/upgrade/mod.rs

@@ -7,7 +7,6 @@ use std::net::TcpStream;
 use std::io;
 use std::io::Result as IoResult;
 use std::io::Error as IoError;
-use std::io::Write;
 use std::fmt::{self, Formatter, Display};
 use stream::{Stream, AsTcpStream};
 use header::extensions::Extension;
@@ -147,11 +146,8 @@ impl<S> WsUpgrade<S>
 	}
 
 	fn send(&mut self, status: StatusCode) -> IoResult<()> {
-		try!(write!(self.stream.writer(),
-		            "{} {}\r\n",
-		            self.request.version,
-		            status));
-		try!(write!(self.stream.writer(), "{}\r\n", self.headers));
+		try!(write!(&mut self.stream, "{} {}\r\n", self.request.version, status));
+		try!(write!(&mut self.stream, "{}\r\n", self.headers));
 		Ok(())
 	}
 }
@@ -194,7 +190,8 @@ impl<S> IntoWs for S
 
 	fn into_ws(mut self) -> Result<WsUpgrade<Self::Stream>, Self::Error> {
 		let request = {
-			let mut reader = BufReader::new(self.reader());
+			// TODO: some extra data might get lost with this reader, try to avoid #72
+			let mut reader = BufReader::new(&mut self);
 			parse_request(&mut reader)
 		};
 

src/stream.rs

@@ -1,37 +1,31 @@
 //! Provides the default stream type for WebSocket connections.
 
 use std::ops::Deref;
+use std::fmt::Arguments;
 use std::io::{self, Read, Write};
 pub use std::net::TcpStream;
 pub use std::net::Shutdown;
 #[cfg(feature="ssl")]
 pub use openssl::ssl::{SslStream, SslContext};
 
-pub trait Splittable {
-	type Reader: Read;
-	type Writer: Write;
-
-	fn split(self) -> io::Result<(Self::Reader, Self::Writer)>;
-}
-
 /// Represents a stream that can be read from, and written to.
 /// This is an abstraction around readable and writable things to be able
 /// to speak websockets over ssl, tcp, unix sockets, etc.
-pub trait Stream {
+pub trait Stream: Read + Write {}
+
+impl<S> Stream for S where S: Read + Write {}
+
+pub trait NetworkStream: Read + Write + AsTcpStream {}
+
+impl<S> NetworkStream for S where S: Read + Write + AsTcpStream {}
+
+pub trait Splittable {
 	type Reader: Read;
 	type Writer: Write;
 
-	/// Get a mutable borrow to the reading component of this stream
-	fn reader(&mut self) -> &mut Self::Reader;
-
-	/// Get a mutable borrow to the writing component of this stream
-	fn writer(&mut self) -> &mut Self::Writer;
+	fn split(self) -> io::Result<(Self::Reader, Self::Writer)>;
 }
 
-pub struct ReadWritePair<R, W>(pub R, pub W)
-	where R: Read,
-	      W: Write;
-
 impl<R, W> Splittable for ReadWritePair<R, W>
 	where R: Read,
 	      W: Write
@@ -44,70 +38,6 @@ impl<R, W> Splittable for ReadWritePair<R, W>
 	}
 }
 
-impl<R, W> Stream for ReadWritePair<R, W>
-	where R: Read,
-	      W: Write
-{
-	type Reader = R;
-	type Writer = W;
-
-	#[inline]
-	fn reader(&mut self) -> &mut R {
-		&mut self.0
-	}
-
-	#[inline]
-	fn writer(&mut self) -> &mut W {
-		&mut self.1
-	}
-}
-
-pub trait ReadWrite: Read + Write {}
-impl<S> ReadWrite for S where S: Read + Write {}
-
-pub struct BoxedStream(pub Box<ReadWrite>);
-
-impl Stream for BoxedStream {
-	type Reader = Box<ReadWrite>;
-	type Writer = Box<ReadWrite>;
-
-	#[inline]
-	fn reader(&mut self) -> &mut Self::Reader {
-		&mut self.0
-	}
-
-	#[inline]
-	fn writer(&mut self) -> &mut Self::Writer {
-		&mut self.0
-	}
-}
-
-pub trait NetworkStream: Read + Write + AsTcpStream {}
-impl<S> NetworkStream for S where S: Read + Write + AsTcpStream {}
-
-pub struct BoxedNetworkStream(pub Box<NetworkStream>);
-
-impl AsTcpStream for BoxedNetworkStream {
-	fn as_tcp(&self) -> &TcpStream {
-		self.0.deref().as_tcp()
-	}
-}
-
-impl Stream for BoxedNetworkStream {
-	type Reader = Box<NetworkStream>;
-	type Writer = Box<NetworkStream>;
-
-	#[inline]
-	fn reader(&mut self) -> &mut Self::Reader {
-		&mut self.0
-	}
-
-	#[inline]
-	fn writer(&mut self) -> &mut Self::Writer {
-		&mut self.0
-	}
-}
-
 impl Splittable for TcpStream {
 	type Reader = TcpStream;
 	type Writer = TcpStream;
@@ -117,23 +47,6 @@ impl Splittable for TcpStream {
 	}
 }
 
-impl<S> Stream for S
-    where S: Read + Write
-{
-	type Reader = Self;
-	type Writer = Self;
-
-	#[inline]
-	fn reader(&mut self) -> &mut S {
-		self
-	}
-
-	#[inline]
-	fn writer(&mut self) -> &mut S {
-		self
-	}
-}
-
 pub trait AsTcpStream {
 	fn as_tcp(&self) -> &TcpStream;
 }
@@ -158,3 +71,51 @@ impl<T> AsTcpStream for Box<T>
 		self.deref().as_tcp()
 	}
 }
+
+pub struct ReadWritePair<R, W>(pub R, pub W)
+	where R: Read,
+	      W: Write;
+
+impl<R, W> Read for ReadWritePair<R, W>
+	where R: Read,
+	      W: Write
+{
+	#[inline(always)]
+	fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+		self.0.read(buf)
+	}
+	#[inline(always)]
+	fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
+		self.0.read_to_end(buf)
+	}
+	#[inline(always)]
+	fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
+		self.0.read_to_string(buf)
+	}
+	#[inline(always)]
+	fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
+		self.0.read_exact(buf)
+	}
+}
+
+impl<R, W> Write for ReadWritePair<R, W>
+	where R: Read,
+	      W: Write
+{
+	#[inline(always)]
+	fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+		self.1.write(buf)
+	}
+	#[inline(always)]
+	fn flush(&mut self) -> io::Result<()> {
+		self.1.flush()
+	}
+	#[inline(always)]
+	fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+		self.1.write_all(buf)
+	}
+	#[inline(always)]
+	fn write_fmt(&mut self, fmt: Arguments) -> io::Result<()> {
+		self.1.write_fmt(fmt)
+	}
+}