Making stream to be a ref in StreamReader

Making stream to be a boxed in StreamReader

src/network/stream_reader.rs

@@ -27,16 +27,16 @@ use std::io::BufRead;
 use consensus::{encode, Decodable};
 
 /// Struct used to configure stream reader function
-pub struct StreamReader<R> {
+pub struct StreamReader<R: BufRead> {
     /// Stream to read from
-    pub stream: R,
+    pub stream: Box<R>,
     /// I/O buffer
     data: Vec<u8>,
     /// Buffer containing unparsed message part
     unparsed: Vec<u8>
 }
 
-impl<R> fmt::Debug for StreamReader<R> {
+impl<R: BufRead> fmt::Debug for StreamReader<R> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "StreamReader with buffer_size={} and unparsed content {:?}",
                self.data.capacity(), self.unparsed)
@@ -46,7 +46,7 @@ impl<R> fmt::Debug for StreamReader<R> {
 impl<R: BufRead> StreamReader<R> {
     /// Constructs new stream reader for a given input stream `stream` with
     /// optional parameter `buffer_size` determining reading buffer size
-    pub fn new(stream: R, buffer_size: Option<usize>) -> StreamReader<R> {
+    pub fn new(stream: Box<R>, buffer_size: Option<usize>) -> StreamReader<R> {
         StreamReader {
             stream,
             data: vec![0u8; buffer_size.unwrap_or(64 * 1024)],
@@ -195,7 +195,8 @@ mod test {
 
     #[test]
     fn parse_multipartmsg_test() {
-        let mut reader = StreamReader::new(io::empty(), None);
+        let stream = io::empty();
+        let mut reader = StreamReader::new(Box::new(stream), None);
         reader.unparsed = MSG_ALERT[..24].to_vec();
         let message: Result<RawNetworkMessage, _> = reader.read_next();
         assert!(message.is_err());
@@ -210,16 +211,18 @@ mod test {
 
     #[test]
     fn read_singlemsg_test() {
-        let message = StreamReader::new(&MSG_VERSION[..], None).read_next().unwrap();
+        let stream = MSG_VERSION[..].to_vec();
+        let stream = stream.as_slice();
+        let message = StreamReader::new(Box::new(stream), None).read_next().unwrap();
         check_version_msg(&message);
     }
 
     #[test]
     fn read_doublemsgs_test() {
         let mut stream = MSG_VERSION.to_vec();
         stream.extend(&MSG_PING);
-
-        let mut reader = StreamReader::new(&stream[..], None);
+        let stream = stream.as_slice();
+        let mut reader = StreamReader::new(Box::new(stream), None);
         let message = reader.read_next().unwrap();
         check_version_msg(&message);
 
@@ -270,7 +273,8 @@ mod test {
             // single message split in two parts to emulate real network conditions
             MSG_VERSION[..24].to_vec(), MSG_VERSION[24..].to_vec()
         ]);
-        let mut reader = StreamReader::new(istream, None);
+        let stream = istream;
+        let mut reader = StreamReader::new(Box::new(stream), None);
 
         // Reading and checking the whole message back
         let message = reader.read_next().unwrap();
@@ -289,7 +293,8 @@ mod test {
             MSG_VERACK.to_vec(),
             MSG_ALERT[..24].to_vec(), MSG_ALERT[24..].to_vec()
         ]);
-        let mut reader = StreamReader::new(istream, None);
+        let stream = istream;
+        let mut reader = StreamReader::new(Box::new(stream), None);
 
         // Reading and checking the first message (Version)
         let message = reader.read_next().unwrap();