more cleanups, put LockedIO into its own module

lumi created 9 years ago

Change summary

src/lib.rs       |  2 ++
src/locked_io.rs | 37 +++++++++++++++++++++++++++++++++++++
src/transport.rs | 29 +++++------------------------
3 files changed, 44 insertions(+), 24 deletions(-)

Detailed changes

src/lib.rs

@@ -6,3 +6,5 @@ pub mod transport;
 pub mod error;
 pub mod jid;
 pub mod client;
+
+mod locked_io;

src/locked_io.rs

@@ -0,0 +1,37 @@
+use std::io;
+use std::io::prelude::*;
+
+use std::sync::{Arc, Mutex};
+
+pub struct LockedIO<T>(Arc<Mutex<T>>);
+
+impl<T> LockedIO<T> {
+    pub fn from(inner: Arc<Mutex<T>>) -> LockedIO<T> {
+        LockedIO(inner)
+    }
+}
+
+impl<T> Clone for LockedIO<T> {
+    fn clone(&self) -> LockedIO<T> {
+        LockedIO(self.0.clone())
+    }
+}
+
+impl<T: Write> io::Write for LockedIO<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let mut inner = self.0.lock().unwrap(); // TODO: make safer
+        inner.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        let mut inner = self.0.lock().unwrap(); // TODO: make safer
+        inner.flush()
+    }
+}
+
+impl<T: Read> io::Read for LockedIO<T> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let mut inner = self.0.lock().unwrap(); // TODO: make safer
+        inner.read(buf)
+    }
+}

src/transport.rs

@@ -1,5 +1,4 @@
 use std::io::prelude::*;
-use std::io;
 
 use std::net::TcpStream;
 
@@ -10,6 +9,8 @@ use std::sync::{Arc, Mutex};
 
 use ns;
 
+use locked_io::LockedIO;
+
 use error::Error;
 
 use openssl::ssl::{SslMethod, SslConnectorBuilder, SslStream};
@@ -19,27 +20,6 @@ pub trait Transport {
     fn read_event(&mut self) -> Result<XmlReaderEvent, Error>;
 }
 
-struct LockedIO<T>(Arc<Mutex<T>>);
-
-impl<T: Write> io::Write for LockedIO<T> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        let mut inner = self.0.lock().unwrap(); // TODO: make safer
-        inner.write(buf)
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        let mut inner = self.0.lock().unwrap(); // TODO: make safer
-        inner.flush()
-    }
-}
-
-impl<T: Read> io::Read for LockedIO<T> {
-    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        let mut inner = self.0.lock().unwrap(); // TODO: make safer
-        inner.read(buf)
-    }
-}
-
 pub struct SslTransport {
     inner: Arc<Mutex<SslStream<TcpStream>>>, // TODO: this feels rather ugly
     reader: EventReader<LockedIO<SslStream<TcpStream>>>, // TODO: especially feels ugly because
@@ -85,8 +65,9 @@ impl SslTransport {
         let stream = parser.into_inner();
         let ssl_connector = SslConnectorBuilder::new(SslMethod::tls())?.build();
         let ssl_stream = Arc::new(Mutex::new(ssl_connector.connect(host, stream)?));
-        let reader = EventReader::new(LockedIO(ssl_stream.clone()));
-        let writer = EventWriter::new(LockedIO(ssl_stream.clone()));
+        let locked_io = LockedIO::from(ssl_stream.clone());
+        let reader = EventReader::new(locked_io.clone());
+        let writer = EventWriter::new(locked_io);
         Ok(SslTransport {
             inner: ssl_stream,
             reader: reader,