Rename ValueEncode::encode() to encode_to().

src/proto/core/user.rs

@@ -58,7 +58,10 @@ impl WriteToPacket for UserStatus {
 }
 
 impl ValueEncode for UserStatus {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     let value = match *self {
       UserStatus::Offline => STATUS_OFFLINE,
       UserStatus::Away => STATUS_AWAY,

src/proto/core/value.rs

@@ -326,9 +326,11 @@ pub struct ValueEncoder<'a> {
 /// This trait is implemented by types that can be encoded into messages using
 /// a `ValueEncoder`.
 pub trait ValueEncode {
-  // TODO: Rename to encode_to().
   /// Attempts to encode `self` with the given encoder.
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError>;
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError>;
 }
 
 impl<'a> ValueEncoder<'a> {
@@ -389,30 +391,42 @@ impl<'a> ValueEncoder<'a> {
     &mut self,
     val: &T,
   ) -> Result<(), ValueEncodeError> {
-    val.encode(self)
+    val.encode_to(self)
   }
 }
 
 impl ValueEncode for u32 {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(*self)
   }
 }
 
 impl ValueEncode for u16 {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u16(*self)
   }
 }
 
 impl ValueEncode for bool {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_bool(*self)
   }
 }
 
 impl ValueEncode for net::Ipv4Addr {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(u32::from(*self))
   }
 }
@@ -426,44 +440,62 @@ impl ValueEncode for net::Ipv4Addr {
 // Value{De,En}code) but it is not really worth the hassle.
 
 impl ValueEncode for str {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(self)
   }
 }
 
 impl ValueEncode for String {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(self)
   }
 }
 
 impl<'a> ValueEncode for &'a String {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(*self)
   }
 }
 
 impl<T: ValueEncode, U: ValueEncode> ValueEncode for (T, U) {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
-    self.0.encode(encoder)?;
-    self.1.encode(encoder)
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
+    self.0.encode_to(encoder)?;
+    self.1.encode_to(encoder)
   }
 }
 
 impl<T: ValueEncode> ValueEncode for [T] {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.len() as u32)?;
     for ref item in self {
-      item.encode(encoder)?;
+      item.encode_to(encoder)?;
     }
     Ok(())
   }
 }
 
 impl<T: ValueEncode> ValueEncode for Vec<T> {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     let slice: &[T] = &*self;
-    slice.encode(encoder)
+    slice.encode_to(encoder)
   }
 }
 

src/proto/peer/message.rs

@@ -72,7 +72,10 @@ impl ValueDecode for Message {
 }
 
 impl ValueEncode for Message {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     match *self {
       Message::PierceFirewall(token) => {
         encoder.encode_u32(CODE_PIERCE_FIREWALL)?;
@@ -80,7 +83,7 @@ impl ValueEncode for Message {
       }
       Message::PeerInit(ref request) => {
         encoder.encode_u32(CODE_PEER_INIT)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       Message::Unknown(_) => unreachable!(),
     }
@@ -137,7 +140,10 @@ impl WriteToPacket for PeerInit {
 }
 
 impl ValueEncode for PeerInit {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.user_name)?;
     encoder.encode_string(&self.connection_type)?;
     encoder.encode_u32(self.token)?;

src/proto/server/request.rs

@@ -148,50 +148,53 @@ impl WriteToPacket for ServerRequest {
 }
 
 impl ValueEncode for ServerRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     match *self {
       ServerRequest::CannotConnectRequest(ref request) => {
         encoder.encode_u32(CODE_CANNOT_CONNECT)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::ConnectToPeerRequest(ref request) => {
         encoder.encode_u32(CODE_CONNECT_TO_PEER)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::FileSearchRequest(ref request) => {
         encoder.encode_u32(CODE_FILE_SEARCH)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::LoginRequest(ref request) => {
         encoder.encode_u32(CODE_LOGIN)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::PeerAddressRequest(ref request) => {
         encoder.encode_u32(CODE_PEER_ADDRESS)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::RoomJoinRequest(ref request) => {
         encoder.encode_u32(CODE_ROOM_JOIN)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::RoomLeaveRequest(ref request) => {
         encoder.encode_u32(CODE_ROOM_LEAVE)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::RoomListRequest => {
         encoder.encode_u32(CODE_ROOM_LIST)?;
       }
       ServerRequest::RoomMessageRequest(ref request) => {
         encoder.encode_u32(CODE_ROOM_MESSAGE)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::SetListenPortRequest(ref request) => {
         encoder.encode_u32(CODE_SET_LISTEN_PORT)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
       ServerRequest::UserStatusRequest(ref request) => {
         encoder.encode_u32(CODE_USER_STATUS)?;
-        request.encode(encoder)?;
+        request.encode_to(encoder)?;
       }
     }
     Ok(())
@@ -275,7 +278,10 @@ impl WriteToPacket for CannotConnectRequest {
 }
 
 impl ValueEncode for CannotConnectRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.token)?;
     encoder.encode_string(&self.user_name)
   }
@@ -310,7 +316,10 @@ impl WriteToPacket for ConnectToPeerRequest {
 }
 
 impl ValueEncode for ConnectToPeerRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.token)?;
     encoder.encode_string(&self.user_name)?;
     encoder.encode_string(&self.connection_type)
@@ -349,7 +358,10 @@ impl WriteToPacket for FileSearchRequest {
 }
 
 impl ValueEncode for FileSearchRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.ticket)?;
     encoder.encode_string(&self.query)
   }
@@ -388,7 +400,10 @@ impl WriteToPacket for LoginRequest {
 }
 
 impl ValueEncode for LoginRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.user_name)?;
     encoder.encode_string(&self.password)?;
     encoder.encode_u32(self.major)?;
@@ -431,7 +446,10 @@ impl WriteToPacket for PeerAddressRequest {
 }
 
 impl ValueEncode for PeerAddressRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.user_name)
   }
 }
@@ -460,7 +478,10 @@ impl WriteToPacket for RoomJoinRequest {
 }
 
 impl ValueEncode for RoomJoinRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)
   }
 }
@@ -491,7 +512,10 @@ impl WriteToPacket for RoomLeaveRequest {
 }
 
 impl ValueEncode for RoomLeaveRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)
   }
 }
@@ -524,7 +548,10 @@ impl WriteToPacket for RoomMessageRequest {
 }
 
 impl ValueEncode for RoomMessageRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)?;
     encoder.encode_string(&self.message)
   }
@@ -555,7 +582,10 @@ impl WriteToPacket for SetListenPortRequest {
 }
 
 impl ValueEncode for SetListenPortRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode(&self.port)
   }
 }
@@ -584,7 +614,10 @@ impl WriteToPacket for UserStatusRequest {
 }
 
 impl ValueEncode for UserStatusRequest {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.user_name)
   }
 }

src/proto/server/response.rs

@@ -117,75 +117,78 @@ impl ReadFromPacket for ServerResponse {
 }
 
 impl ValueEncode for ServerResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     match *self {
       ServerResponse::ConnectToPeerResponse(ref response) => {
         encoder.encode_u32(CODE_CONNECT_TO_PEER)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::FileSearchResponse(ref response) => {
         encoder.encode_u32(CODE_FILE_SEARCH)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::LoginResponse(ref response) => {
         encoder.encode_u32(CODE_LOGIN)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::ParentMinSpeedResponse(ref response) => {
         encoder.encode_u32(CODE_PARENT_MIN_SPEED)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::ParentSpeedRatioResponse(ref response) => {
         encoder.encode_u32(CODE_PARENT_SPEED_RATIO)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::PeerAddressResponse(ref response) => {
         encoder.encode_u32(CODE_PEER_ADDRESS)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::PrivilegedUsersResponse(ref response) => {
         encoder.encode_u32(CODE_PRIVILEGED_USERS)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::RoomJoinResponse(ref response) => {
         encoder.encode_u32(CODE_ROOM_JOIN)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::RoomLeaveResponse(ref response) => {
         encoder.encode_u32(CODE_ROOM_LEAVE)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::RoomListResponse(ref response) => {
         encoder.encode_u32(CODE_ROOM_LIST)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::RoomMessageResponse(ref response) => {
         encoder.encode_u32(CODE_ROOM_MESSAGE)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::RoomTickersResponse(ref response) => {
         encoder.encode_u32(CODE_ROOM_TICKERS)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::RoomUserJoinedResponse(ref response) => {
         encoder.encode_u32(CODE_ROOM_USER_JOINED)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::RoomUserLeftResponse(ref response) => {
         encoder.encode_u32(CODE_ROOM_USER_LEFT)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::UserInfoResponse(ref response) => {
         encoder.encode_u32(CODE_USER_INFO)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::UserStatusResponse(ref response) => {
         encoder.encode_u32(CODE_USER_STATUS)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       ServerResponse::WishlistIntervalResponse(ref response) => {
         encoder.encode_u32(CODE_WISHLIST_INTERVAL)?;
-        response.encode(encoder)?;
+        response.encode_to(encoder)?;
       }
       _ => {
         unimplemented!();
@@ -315,7 +318,10 @@ impl ReadFromPacket for ConnectToPeerResponse {
 }
 
 impl ValueEncode for ConnectToPeerResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode(&self.user_name)?;
     encoder.encode(&self.connection_type)?;
     encoder.encode(&self.ip)?;
@@ -371,7 +377,10 @@ impl ReadFromPacket for FileSearchResponse {
 }
 
 impl ValueEncode for FileSearchResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.user_name)?;
     encoder.encode_u32(self.ticket)?;
     encoder.encode_string(&self.query)
@@ -434,7 +443,10 @@ impl ReadFromPacket for LoginResponse {
 }
 
 impl ValueEncode for LoginResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     match *self {
       LoginResponse::LoginOk {
         ref motd,
@@ -496,7 +508,10 @@ impl ReadFromPacket for ParentMinSpeedResponse {
 }
 
 impl ValueEncode for ParentMinSpeedResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.value)
   }
 }
@@ -525,7 +540,10 @@ impl ReadFromPacket for ParentSpeedRatioResponse {
 }
 
 impl ValueEncode for ParentSpeedRatioResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.value)
   }
 }
@@ -554,12 +572,19 @@ impl ReadFromPacket for PeerAddressResponse {
     let ip = packet.read_value()?;
     let port = packet.read_value()?;
 
-    Ok(PeerAddressResponse { user_name, ip, port })
+    Ok(PeerAddressResponse {
+      user_name,
+      ip,
+      port,
+    })
   }
 }
 
 impl ValueEncode for PeerAddressResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode(&self.user_name)?;
     encoder.encode(&self.ip)?;
     encoder.encode_u16(self.port)
@@ -571,7 +596,11 @@ impl ValueDecode for PeerAddressResponse {
     let user_name = decoder.decode()?;
     let ip = decoder.decode()?;
     let port = decoder.decode()?;
-    Ok(PeerAddressResponse { user_name, ip, port })
+    Ok(PeerAddressResponse {
+      user_name,
+      ip,
+      port,
+    })
   }
 }
 
@@ -592,7 +621,10 @@ impl ReadFromPacket for PrivilegedUsersResponse {
 }
 
 impl ValueEncode for PrivilegedUsersResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode(&self.users)
   }
 }
@@ -755,7 +787,10 @@ fn build_user(
 }
 
 impl ValueEncode for UserInfo {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.average_speed)?;
     encoder.encode_u32(self.num_downloads)?;
     encoder.encode_u32(self.unknown)?;
@@ -782,7 +817,10 @@ impl ValueDecode for UserInfo {
 }
 
 impl ValueEncode for RoomJoinResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     let mut user_names = vec![];
     let mut user_statuses = vec![];
     let mut user_infos = vec![];
@@ -891,7 +929,10 @@ impl ReadFromPacket for RoomLeaveResponse {
 }
 
 impl ValueEncode for RoomLeaveResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)
   }
 }
@@ -1019,7 +1060,10 @@ impl RoomListResponse {
 }
 
 impl ValueEncode for RoomListResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     Self::encode_rooms(&self.rooms, encoder)?;
     Self::encode_rooms(&self.owned_private_rooms, encoder)?;
     Self::encode_rooms(&self.other_private_rooms, encoder)?;
@@ -1067,7 +1111,10 @@ impl ReadFromPacket for RoomMessageResponse {
 }
 
 impl ValueEncode for RoomMessageResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)?;
     encoder.encode_string(&self.user_name)?;
     encoder.encode_string(&self.message)
@@ -1114,7 +1161,10 @@ impl ReadFromPacket for RoomTickersResponse {
 }
 
 impl ValueEncode for RoomTickersResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)?;
     encoder.encode(&self.tickers)
   }
@@ -1172,11 +1222,14 @@ impl ReadFromPacket for RoomUserJoinedResponse {
 }
 
 impl ValueEncode for RoomUserJoinedResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)?;
     encoder.encode_string(&self.user.name)?;
-    self.user.status.encode(encoder)?;
-    UserInfo::from_user(&self.user).encode(encoder)?;
+    self.user.status.encode_to(encoder)?;
+    UserInfo::from_user(&self.user).encode_to(encoder)?;
     encoder.encode_u32(self.user.num_free_slots as u32)?;
     encoder.encode_string(&self.user.country)
   }
@@ -1219,7 +1272,10 @@ impl ReadFromPacket for RoomUserLeftResponse {
 }
 
 impl ValueEncode for RoomUserLeftResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.room_name)?;
     encoder.encode_string(&self.user_name)
   }
@@ -1267,7 +1323,10 @@ impl ReadFromPacket for UserInfoResponse {
 }
 
 impl ValueEncode for UserInfoResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.user_name)?;
     encoder.encode_u32(self.average_speed as u32)?;
     encoder.encode_u32(self.num_downloads as u32)?;
@@ -1318,9 +1377,12 @@ impl ReadFromPacket for UserStatusResponse {
 }
 
 impl ValueEncode for UserStatusResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_string(&self.user_name)?;
-    self.status.encode(encoder)?;
+    self.status.encode_to(encoder)?;
     encoder.encode_bool(self.is_privileged)
   }
 }
@@ -1355,7 +1417,10 @@ impl ReadFromPacket for WishlistIntervalResponse {
 }
 
 impl ValueEncode for WishlistIntervalResponse {
-  fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+  fn encode_to(
+    &self,
+    encoder: &mut ValueEncoder,
+  ) -> Result<(), ValueEncodeError> {
     encoder.encode_u32(self.seconds)
   }
 }