Rename JoinRoom to RoomJoin.

src/client.rs

@@ -1,4 +1,3 @@
-use std::collections;
 use std::sync::mpsc;
 
 use mio;
@@ -127,8 +126,8 @@ impl Client {
                 self.controller_connected = false;
             },
 
-            control::Request::JoinRoomRequest(room_name) =>
-                self.handle_join_room_request(room_name),
+            control::Request::RoomJoinRequest(room_name) =>
+                self.handle_room_join_request(room_name),
 
             control::Request::LoginStatusRequest =>
                 self.handle_login_status_request(),
@@ -147,7 +146,7 @@ impl Client {
         }
     }
 
-    fn handle_join_room_request(&mut self, room_name: String) {
+    fn handle_room_join_request(&mut self, room_name: String) {
         // First check that we are not already a member.
         // Enclosed in a block otherwise the mutable borrow of self.rooms
         // prevents from calling self.server_send.
@@ -181,7 +180,7 @@ impl Client {
                 }
             }
         }
-        self.server_send(ServerRequest::JoinRoomRequest(JoinRoomRequest {
+        self.server_send(ServerRequest::RoomJoinRequest(RoomJoinRequest {
             room_name: room_name
         }));
     }
@@ -234,15 +233,15 @@ impl Client {
 
     fn handle_server_response(&mut self, response: ServerResponse) {
         match response {
-            ServerResponse::JoinRoomResponse(response) =>
-                self.handle_join_room_response(response),
-
             ServerResponse::LoginResponse(response) =>
                 self.handle_login_response(response),
 
             ServerResponse::PrivilegedUsersResponse(response) =>
                 self.handle_privileged_users_response(response),
 
+            ServerResponse::RoomJoinResponse(response) =>
+                self.handle_room_join_response(response),
+
             ServerResponse::RoomListResponse(response) =>
                 self.handle_room_list_response(response),
 
@@ -259,7 +258,7 @@ impl Client {
         }
     }
 
-    fn handle_join_room_response(&mut self, mut response: JoinRoomResponse) {
+    fn handle_room_join_response(&mut self, mut response: RoomJoinResponse) {
         // Join the room and store the received information.
         self.rooms.join(
             &response.room_name, response.owner, response.operators,
@@ -270,10 +269,10 @@ impl Client {
             self.users.insert(name, user);
         }
 
-        let control_response = control::JoinRoomResponse {
+        let control_response = control::RoomJoinResponse {
             room_name: response.room_name
         };
-        self.control_send(control::Response::JoinRoomResponse(
+        self.control_send(control::Response::RoomJoinResponse(
                 control_response));
     }
 
@@ -310,7 +309,7 @@ impl Client {
     }
 
     fn handle_privileged_users_response(
-        &mut self, mut response: PrivilegedUsersResponse)
+        &mut self, response: PrivilegedUsersResponse)
     {
         self.users.update_privileges(response);
     }
@@ -342,7 +341,7 @@ impl Client {
     }
 
     fn handle_user_joined_room_response(
-        &mut self, mut response: UserJoinedRoomResponse)
+        &mut self, response: UserJoinedRoomResponse)
     {
         if let Some(room) = self.rooms.get_mut(&response.room_name) {
             room.members.insert(response.user_name.clone());

src/control/request.rs

@@ -10,7 +10,7 @@ pub enum Request {
     /// sent.
     DisconnectNotification,
     /// The controller wants to join a room. Contains the room name.
-    JoinRoomRequest(String),
+    RoomJoinRequest(String),
     /// The controller wants to know what the login status is.
     LoginStatusRequest,
     /// The controller wants to know the list of visible chat rooms.

src/control/response.rs

@@ -4,14 +4,14 @@ use room;
 /// to the controller.
 #[derive(Debug, RustcDecodable, RustcEncodable)]
 pub enum Response {
-    JoinRoomResponse(JoinRoomResponse),
+    RoomJoinResponse(RoomJoinResponse),
     LoginStatusResponse(LoginStatusResponse),
     RoomListResponse(RoomListResponse),
     RoomMessageResponse(RoomMessageResponse),
 }
 
 #[derive(Debug, RustcEncodable, RustcDecodable)]
-pub struct JoinRoomResponse {
+pub struct RoomJoinResponse {
     pub room_name: String,
 }
 

src/proto/server/constants.rs

@@ -2,7 +2,7 @@ pub const CODE_LOGIN:              u32 = 1;
 pub const CODE_SET_LISTEN_PORT:    u32 = 2;
 pub const CODE_PEER_ADDRESS:       u32 = 3;
 pub const CODE_ROOM_MESSAGE:       u32 = 13;
-pub const CODE_JOIN_ROOM:          u32 = 14;
+pub const CODE_ROOM_JOIN:          u32 = 14;
 pub const CODE_USER_JOINED_ROOM:   u32 = 16;
 pub const CODE_CONNECT_TO_PEER:    u32 = 18;
 pub const CODE_ROOM_LIST:          u32 = 64;

src/proto/server/request.rs

@@ -16,7 +16,7 @@ trait WriteToPacket {
 
 #[derive(Debug)]
 pub enum ServerRequest {
-    JoinRoomRequest(JoinRoomRequest),
+    RoomJoinRequest(RoomJoinRequest),
     LoginRequest(LoginRequest),
     PeerAddressRequest(PeerAddressRequest),
     RoomListRequest,
@@ -27,8 +27,8 @@ pub enum ServerRequest {
 impl ServerRequest {
     pub fn to_packet(&self) -> io::Result<Packet> {
         let (mut packet, request): (Packet, &WriteToPacket) = match *self {
-            ServerRequest::JoinRoomRequest(ref request) =>
-                (Packet::new(CODE_JOIN_ROOM), request),
+            ServerRequest::RoomJoinRequest(ref request) =>
+                (Packet::new(CODE_ROOM_JOIN), request),
 
             ServerRequest::LoginRequest(ref request) =>
                 (Packet::new(CODE_LOGIN), request),
@@ -61,11 +61,11 @@ fn md5_str(string: &str) -> String {
  *===========*/
 
 #[derive(Debug)]
-pub struct JoinRoomRequest {
+pub struct RoomJoinRequest {
     pub room_name: String
 }
 
-impl WriteToPacket for JoinRoomRequest {
+impl WriteToPacket for RoomJoinRequest {
     fn write_to_packet(&self, packet: &mut Packet) -> io::Result<()> {
         try!(packet.write_str(&self.room_name));
         Ok(())

src/proto/server/response.rs

@@ -21,7 +21,7 @@ pub trait FromPacket: Sized {
 #[derive(Debug)]
 pub enum ServerResponse {
     ConnectToPeerResponse(ConnectToPeerResponse),
-    JoinRoomResponse(JoinRoomResponse),
+    RoomJoinResponse(RoomJoinResponse),
     LoginResponse(LoginResponse),
     PeerAddressResponse(PeerAddressResponse),
     PrivilegedUsersResponse(PrivilegedUsersResponse),
@@ -46,9 +46,9 @@ impl FromPacket for ServerResponse {
                     try!(ConnectToPeerResponse::from_packet(packet))
                 ),
 
-            CODE_JOIN_ROOM =>
-                ServerResponse::JoinRoomResponse(
-                    try!(JoinRoomResponse::from_packet(packet))
+            CODE_ROOM_JOIN =>
+                ServerResponse::RoomJoinResponse(
+                    try!(RoomJoinResponse::from_packet(packet))
                 ),
 
             CODE_LOGIN =>
@@ -143,117 +143,6 @@ impl FromPacket for ConnectToPeerResponse {
     }
 }
 
-/*===========*
- * JOIN ROOM *
- *===========*/
-
-#[derive(Debug)]
-pub struct JoinRoomResponse {
-    pub room_name: String,
-    pub users: Vec<(String, user::User)>,
-    pub owner: Option<String>,
-    pub operators: Vec<String>,
-}
-
-impl FromPacket for JoinRoomResponse {
-    fn from_packet(packet: &mut Packet) -> result::Result<Self> {
-        let mut response = JoinRoomResponse {
-            room_name: try!(packet.read_str()),
-            users: Vec::new(),
-            owner: None,
-            operators: Vec::new(),
-        };
-
-        let result: result::Result<usize> =
-            packet.read_array(&mut response.users, |packet| {
-                let name = try!(packet.read_str());
-                let user = user::User {
-                    status:         user::Status::Offline,
-                    average_speed:  0,
-                    num_downloads:  0,
-                    unknown:        0,
-                    num_files:      0,
-                    num_folders:    0,
-                    num_free_slots: 0,
-                    country:        String::new(),
-                };
-                Ok((name, user))
-            });
-        try!(result);
-
-        try!(response.read_user_infos(packet));
-
-        if packet.bytes_remaining() > 0 {
-            response.owner = Some(try!(packet.read_str()));
-            try!(packet.read_array(&mut response.operators, Packet::read_str));
-        }
-
-        Ok(response)
-    }
-}
-
-impl JoinRoomResponse {
-    fn read_user_infos(&mut self, packet: &mut Packet)
-        -> result::Result<()>
-    {
-        let num_statuses_res: result::Result<usize> =
-            packet.read_array_with(|packet, i| {
-                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
-                    let status_u32 = try!(packet.read_uint());
-                    user.status = try!(user::Status::from_u32(status_u32));
-                }
-                Ok(())
-            });
-        let num_statuses = try!(num_statuses_res);
-
-        let num_infos_res: result::Result<usize> =
-            packet.read_array_with(|packet, i| {
-                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
-                    user.average_speed = try!(packet.read_uint()) as usize;
-                    user.num_downloads = try!(packet.read_uint()) as usize;
-                    user.unknown       = try!(packet.read_uint()) as usize;
-                    user.num_files     = try!(packet.read_uint()) as usize;
-                    user.num_folders   = try!(packet.read_uint()) as usize;
-                }
-                Ok(())
-            });
-        let num_infos = try!(num_infos_res);
-
-        let num_free_slots_res: result::Result<usize> =
-            packet.read_array_with(|packet, i| {
-                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
-                    user.num_free_slots = try!(packet.read_uint()) as usize;
-                }
-                Ok(())
-            });
-        let num_free_slots = try!(num_free_slots_res);
-
-        let num_countries_res: result::Result<usize> =
-            packet.read_array_with(|packet, i| {
-                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
-                    user.country = try!(packet.read_str());
-                }
-                Ok(())
-            });
-        let num_countries = try!(num_countries_res);
-
-        let num_users = self.users.len();
-        if num_users != num_statuses ||
-            num_users != num_infos ||
-            num_users != num_free_slots ||
-            num_users != num_countries
-        {
-            warn!(
-                "JoinRoomResponse: mismatched vector sizes {}, {}, {}, {}, {}",
-                num_users, num_statuses, num_infos, num_free_slots,
-                num_countries
-            );
-        }
-
-        Ok(())
-    }
-}
-
 /*=======*
  * LOGIN *
  *=======*/
@@ -375,6 +264,117 @@ impl FromPacket for PrivilegedUsersResponse {
     }
 }
 
+/*===========*
+ * ROOM JOIN *
+ *===========*/
+
+#[derive(Debug)]
+pub struct RoomJoinResponse {
+    pub room_name: String,
+    pub users: Vec<(String, user::User)>,
+    pub owner: Option<String>,
+    pub operators: Vec<String>,
+}
+
+impl FromPacket for RoomJoinResponse {
+    fn from_packet(packet: &mut Packet) -> result::Result<Self> {
+        let mut response = RoomJoinResponse {
+            room_name: try!(packet.read_str()),
+            users: Vec::new(),
+            owner: None,
+            operators: Vec::new(),
+        };
+
+        let result: result::Result<usize> =
+            packet.read_array(&mut response.users, |packet| {
+                let name = try!(packet.read_str());
+                let user = user::User {
+                    status:         user::Status::Offline,
+                    average_speed:  0,
+                    num_downloads:  0,
+                    unknown:        0,
+                    num_files:      0,
+                    num_folders:    0,
+                    num_free_slots: 0,
+                    country:        String::new(),
+                };
+                Ok((name, user))
+            });
+        try!(result);
+
+        try!(response.read_user_infos(packet));
+
+        if packet.bytes_remaining() > 0 {
+            response.owner = Some(try!(packet.read_str()));
+            try!(packet.read_array(&mut response.operators, Packet::read_str));
+        }
+
+        Ok(response)
+    }
+}
+
+impl RoomJoinResponse {
+    fn read_user_infos(&mut self, packet: &mut Packet)
+        -> result::Result<()>
+    {
+        let num_statuses_res: result::Result<usize> =
+            packet.read_array_with(|packet, i| {
+                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
+                    let status_u32 = try!(packet.read_uint());
+                    user.status = try!(user::Status::from_u32(status_u32));
+                }
+                Ok(())
+            });
+        let num_statuses = try!(num_statuses_res);
+
+        let num_infos_res: result::Result<usize> =
+            packet.read_array_with(|packet, i| {
+                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
+                    user.average_speed = try!(packet.read_uint()) as usize;
+                    user.num_downloads = try!(packet.read_uint()) as usize;
+                    user.unknown       = try!(packet.read_uint()) as usize;
+                    user.num_files     = try!(packet.read_uint()) as usize;
+                    user.num_folders   = try!(packet.read_uint()) as usize;
+                }
+                Ok(())
+            });
+        let num_infos = try!(num_infos_res);
+
+        let num_free_slots_res: result::Result<usize> =
+            packet.read_array_with(|packet, i| {
+                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
+                    user.num_free_slots = try!(packet.read_uint()) as usize;
+                }
+                Ok(())
+            });
+        let num_free_slots = try!(num_free_slots_res);
+
+        let num_countries_res: result::Result<usize> =
+            packet.read_array_with(|packet, i| {
+                if let Some(&mut (_, ref mut user)) = self.users.get_mut(i) {
+                    user.country = try!(packet.read_str());
+                }
+                Ok(())
+            });
+        let num_countries = try!(num_countries_res);
+
+        let num_users = self.users.len();
+        if num_users != num_statuses ||
+            num_users != num_infos ||
+            num_users != num_free_slots ||
+            num_users != num_countries
+        {
+            warn!(
+                "RoomJoinResponse: mismatched vector sizes {}, {}, {}, {}, {}",
+                num_users, num_statuses, num_infos, num_free_slots,
+                num_countries
+            );
+        }
+
+        Ok(())
+    }
+}
+
 /*===========*
  * ROOM LIST *
  *===========*/

src/room.rs

@@ -1,7 +1,6 @@
 use std::collections;
 use std::mem;
 
-use control;
 use proto::server;
 use user;