Remove useless result module.

src/handler.rs

@@ -6,9 +6,8 @@ use std::sync::mpsc::Sender;
 use mio::{EventLoop, EventSet, Handler, PollOpt, Token};
 use mio::tcp::TcpStream;
 
-use proto::{Packet, PacketStream, ReadFromPacket, Request, Response};
+use proto::{Packet, PacketStream, Request, Response};
 use proto::server::*;
-use result;
 
 struct TokenCounter {
     counter: usize,
@@ -81,61 +80,56 @@ impl ConnectionHandler {
 
     fn read_server(&mut self) {
         loop {
-            match self.read_server_once() {
-                Ok(true) => (),
-                Ok(false) => break,
-                Err(e) => {
-                    error!("Error reading server: {}", e);
-                    break;
+            let mut packet = match self.server_stream.try_read() {
+                Ok(Some(packet)) => packet,
+                Ok(None)         => break,
+                Err(err)         => {
+                    error!("Error reading server: {}", err);
+                    break
+                }
+            };
+
+            debug!("Read packet with size {}", packet.bytes_remaining());
+
+            let response = match packet.read_value() {
+                Ok(resp) => {
+                    debug!("Received server response: {:?}", resp);
+                    Response::ServerResponse(resp)
+                },
+                Err(err) => {
+                    error!("Error parsing server packet: {}", err);
+                    break
                 }
+            };
+
+            if let Err(err) = self.client_tx.send(response) {
+                error!("Error sending server response to client: {}", err);
+                break
             }
         }
     }
 
     fn write_server(&mut self) {
         loop {
-            match self.write_server_once() {
-                Ok(true) => (),
-                Ok(false) => break,
+            let mut packet = match self.server_queue.pop_front() {
+                Some(packet) => packet,
+                None => break
+            };
+
+            match self.server_stream.try_write(&mut packet) {
+                Ok(Some(())) => (), // continue looping
+                Ok(None)     => {
+                    self.server_queue.push_front(packet);
+                    break
+                },
                 Err(e) => {
-                    error!("Error writing server: {}", e);
-                    break;
+                    error!("Error writing server stream: {}", e);
+                    break
                 }
             }
         }
     }
 
-    fn read_server_once(&mut self) -> result::Result<bool> {
-        let mut packet = match try!(self.server_stream.try_read()) {
-            Some(packet) => packet,
-            None => return Ok(false),
-        };
-
-        debug!("Read packet with size {}", packet.bytes_remaining());
-        let server_response = try!(
-            ServerResponse::read_from_packet(&mut packet)
-        );
-        debug!("Received server response: {:?}", server_response);
-
-        try!(self.client_tx.send(Response::ServerResponse(server_response)));
-        Ok(true)
-    }
-
-    fn write_server_once(&mut self) -> io::Result<bool> {
-        let mut packet = match self.server_queue.pop_front() {
-            Some(packet) => packet,
-            None => return Ok(false),
-        };
-
-        match try!(self.server_stream.try_write(&mut packet)) {
-            Some(()) => Ok(true),
-            None => {
-                self.server_queue.push_front(packet);
-                Ok(false)
-            }
-        }
-    }
-
     fn notify_server(&mut self, request: ServerRequest) -> io::Result<()> {
         debug!("Sending server request: {:?}", request);
         let packet = try!(request.to_packet());
@@ -143,15 +137,19 @@ impl ConnectionHandler {
         Ok(())
     }
 
+    /// Re-register the server socket with the event loop.
     fn reregister_server(&mut self, event_loop: &mut EventLoop<Self>) {
         let event_set = if self.server_queue.len() > 0 {
             EventSet::readable() | EventSet::writable()
         } else {
             EventSet::readable()
         };
+
         let poll_opt = PollOpt::edge() | PollOpt::oneshot();
+
         self.server_stream.reregister(
-            event_loop, self.server_token, event_set, poll_opt).unwrap();
+            event_loop, self.server_token, event_set, poll_opt
+        ).unwrap();
     }
 }
 

src/main.rs

@@ -3,7 +3,6 @@
 mod client;
 mod config;
 mod control;
-mod result;
 mod handler;
 mod proto;
 mod room;

src/result.rs

@@ -1,113 +0,0 @@
-use std::fmt;
-use std::io;
-use std::result;
-use std::error;
-use std::str;
-use std::sync::mpsc;
-
-use rustc_serialize::json;
-
-use control;
-use proto;
-
-#[derive(Debug)]
-pub enum Error {
-    IOError(io::Error),
-    JSONEncoderError(json::EncoderError),
-    JSONDecoderError(json::DecoderError),
-    PacketReadError(proto::PacketReadError),
-    SendControlRequestError(mpsc::SendError<control::Request>),
-    SendProtoResponseError(mpsc::SendError<proto::Response>),
-    Utf8Error(str::Utf8Error),
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Error::IOError(ref err) =>
-                write!(fmt, "IOError: {}", err),
-            Error::JSONEncoderError(ref err) =>
-                write!(fmt, "JSONEncoderError: {}", err),
-            Error::JSONDecoderError(ref err) =>
-                write!(fmt, "JSONDecoderError: {}", err),
-            Error::PacketReadError(ref err) =>
-                write!(fmt, "PacketReadError: {}", err),
-            Error::SendControlRequestError(ref err) =>
-                write!(fmt, "SendControlRequestError: {}", err),
-            Error::SendProtoResponseError(ref err) =>
-                write!(fmt, "SendProtoResponseError: {}", err),
-            Error::Utf8Error(ref err) =>
-                write!(fmt, "Utf8Error: {}", err),
-        }
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::IOError(_)                 => "IOError",
-            Error::JSONEncoderError(_)        => "JSONEncoderError",
-            Error::JSONDecoderError(_)        => "JSONDecoderError",
-            Error::PacketReadError(_)         => "PacketReadError",
-            Error::SendControlRequestError(_) => "SendControlRequestError",
-            Error::SendProtoResponseError(_)  => "SendProtoResponseError",
-            Error::Utf8Error(_)               => "Utf8Error",
-        }
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {
-            Error::IOError(ref err)                 => Some(err),
-            Error::JSONEncoderError(ref err)        => Some(err),
-            Error::JSONDecoderError(ref err)        => Some(err),
-            Error::PacketReadError(ref err)         => Some(err),
-            Error::SendControlRequestError(ref err) => Some(err),
-            Error::SendProtoResponseError(ref err)  => Some(err),
-            Error::Utf8Error(ref err)               => Some(err),
-        }
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(err: io::Error) -> Self {
-        Error::IOError(err)
-    }
-}
-
-impl From<json::EncoderError> for Error {
-    fn from(err: json::EncoderError) -> Self {
-        Error::JSONEncoderError(err)
-    }
-}
-
-impl From<json::DecoderError> for Error {
-    fn from(err: json::DecoderError) -> Self {
-        Error::JSONDecoderError(err)
-    }
-}
-
-impl From<proto::PacketReadError> for Error {
-    fn from(err: proto::PacketReadError) -> Self {
-        Error::PacketReadError(err)
-    }
-}
-
-impl From<mpsc::SendError<control::Request>> for Error {
-    fn from(err: mpsc::SendError<control::Request>) -> Self {
-        Error::SendControlRequestError(err)
-    }
-}
-
-impl From<mpsc::SendError<proto::Response>> for Error {
-    fn from(err: mpsc::SendError<proto::Response>) -> Self {
-        Error::SendProtoResponseError(err)
-    }
-}
-
-impl From<str::Utf8Error> for Error {
-    fn from(err: str::Utf8Error) -> Self {
-        Error::Utf8Error(err)
-    }
-}
-
-pub type Result<T> = result::Result<T, Error>;