Refactor ControlRequest and ControlResponse.

src/client.rs

@@ -12,7 +12,7 @@ use room;
 #[derive(Debug)]
 enum IncomingMessage {
     ServerResponse(ServerResponse),
-    ControlRequest(control::ControlRequest),
+    ControlRequest(control::Request),
 }
 
 #[derive(Debug, Clone)]
@@ -26,8 +26,8 @@ pub struct Client {
     proto_tx: mio::Sender<Request>,
     proto_rx: mpsc::Receiver<Response>,
 
-    control_tx: mpsc::Sender<control::ControlResponse>,
-    control_rx: mpsc::Receiver<control::ControlRequest>,
+    control_tx: mpsc::Sender<control::Response>,
+    control_rx: mpsc::Receiver<control::Request>,
 
     login_status: LoginStatus,
 
@@ -39,8 +39,8 @@ impl Client {
     pub fn new(
         proto_tx: mio::Sender<Request>,
         proto_rx: mpsc::Receiver<Response>,
-        control_tx: mpsc::Sender<control::ControlResponse>,
-        control_rx: mpsc::Receiver<control::ControlRequest>)
+        control_tx: mpsc::Sender<control::Response>,
+        control_rx: mpsc::Receiver<control::Request>)
         -> Self
     {
         Client {
@@ -92,9 +92,9 @@ impl Client {
         }
     }
 
-    fn handle_control_request(&mut self, request: control::ControlRequest) {
+    fn handle_control_request(&mut self, request: control::Request) {
         match request {
-            control::ControlRequest::LoginStatusRequest =>
+            control::Request::LoginStatusRequest =>
                 self.handle_login_status_request(),
 
             _ =>{
@@ -123,7 +123,7 @@ impl Client {
                 },
         };
         debug!("Sending control response: {:?}", response);
-        self.control_tx.send(control::ControlResponse::LoginStatusResponse(response));
+        self.control_tx.send(control::Response::LoginStatusResponse(response));
     }
 
     fn handle_server_response(&mut self, response: ServerResponse) {

src/control/controller.rs

@@ -28,7 +28,7 @@ enum Error {
     IOError(io::Error),
     JSONEncoderError(json::EncoderError),
     JSONDecoderError(json::DecoderError),
-    SendError(mpsc::SendError<ControlRequest>),
+    SendError(mpsc::SendError<Request>),
     Utf8Error(str::Utf8Error),
     WebSocketError(websocket::result::WebSocketError),
 }
@@ -70,8 +70,8 @@ impl From<json::DecoderError> for Error {
     }
 }
 
-impl From<mpsc::SendError<ControlRequest>> for Error {
-    fn from(err: mpsc::SendError<ControlRequest>) -> Self {
+impl From<mpsc::SendError<Request>> for Error {
+    fn from(err: mpsc::SendError<Request>) -> Self {
         Error::SendError(err)
     }
 }
@@ -89,13 +89,13 @@ impl From<websocket::result::WebSocketError> for Error {
 }
 
 pub struct Controller {
-    client_tx: mpsc::Sender<ControlRequest>,
-    client_rx: mpsc::Receiver<ControlResponse>,
+    client_tx: mpsc::Sender<Request>,
+    client_rx: mpsc::Receiver<Response>,
 }
 
 impl Controller {
-    pub fn new(tx: mpsc::Sender<ControlRequest>,
-               rx: mpsc::Receiver<ControlResponse>)
+    pub fn new(tx: mpsc::Sender<Request>,
+               rx: mpsc::Receiver<Response>)
         -> Self
     {
         Controller {
@@ -150,7 +150,7 @@ impl Controller {
 
     fn receiver_loop(
         mut receiver: WebSocketReceiver,
-        client_tx: mpsc::Sender<ControlRequest>,
+        client_tx: mpsc::Sender<Request>,
         sender_tx: mpsc::Sender<()>)
     {
         for message_result in receiver.incoming_messages() {
@@ -186,7 +186,7 @@ impl Controller {
 
     fn handle_text_message(
         payload_bytes: &[u8],
-        client_tx: &mpsc::Sender<ControlRequest>)
+        client_tx: &mpsc::Sender<Request>)
         -> Result<(), Error>
     {
         let payload = try!(str::from_utf8(payload_bytes));
@@ -197,7 +197,7 @@ impl Controller {
 
     fn sender_loop(
         mut sender: WebSocketSender,
-        client_rx: &mut mpsc::Receiver<ControlResponse>,
+        client_rx: &mut mpsc::Receiver<Response>,
         sender_rx: mpsc::Receiver<()>)
     {
         loop {
@@ -224,7 +224,7 @@ impl Controller {
         sender.shutdown_all().unwrap();
     }
 
-    fn send_response(sender: &mut WebSocketSender, response: ControlResponse)
+    fn send_response(sender: &mut WebSocketSender, response: Response)
         -> Result<(), Error>
     {
         let encoded = try!(json::encode(&response));

src/control/request.rs

@@ -1,5 +1,5 @@
 #[derive(Debug, RustcDecodable, RustcEncodable)]
-pub enum ControlRequest {
+pub enum Request {
     LoginStatusRequest,
     RoomListRequest,
 }

src/control/response.rs

@@ -1,7 +1,7 @@
 use room;
 
 #[derive(Debug, RustcDecodable, RustcEncodable)]
-pub enum ControlResponse {
+pub enum Response {
     LoginStatusResponse(LoginStatusResponse),
     RoomListResponse(RoomListResponse),
 }