Change WriteToPacket signature to use &self.

src/proto/packet.rs

@@ -81,7 +81,7 @@ impl MutPacket {
     }
 
     /// Provides the main way to write data into a binary packet.
-    pub fn write_value<T>(&mut self, val: T) -> io::Result<()>
+    pub fn write_value<T>(&mut self, val: &T) -> io::Result<()>
         where T: WriteToPacket
     {
         val.write_to_packet(self)
@@ -192,24 +192,21 @@ pub trait ReadFromPacket: Sized {
 /// 32-bit integers are serialized in 4 bytes, little-endian.
 impl ReadFromPacket for u32 {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        packet.read_u32::<LittleEndian>().map_err(PacketReadError::from)
+        Ok(try!(packet.read_u32::<LittleEndian>()))
     }
 }
 
 /// For convenience, usize's are deserialized as u32's then casted.
 impl ReadFromPacket for usize {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let n: u32 = try!(packet.read_value());
-        Ok(n as usize)
+        Ok(try!(u32::read_from_packet(packet)) as usize)
     }
 }
 
 /// Booleans are serialized as single bytes, containing either 0 or 1.
 impl ReadFromPacket for bool {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let mut buffer = vec![0];
-        try!(packet.read(&mut buffer));
-        match buffer[0] {
+        match try!(packet.read_u8()) {
             0 => Ok(false),
             1 => Ok(true),
             n => Err(PacketReadError::InvalidBoolError(n))
@@ -220,7 +217,7 @@ impl ReadFromPacket for bool {
 /// 16-bit integers are serialized as 32-bit integers.
 impl ReadFromPacket for u16 {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let n: u32 = try!(packet.read_value());
+        let n = try!(u32::read_from_packet(packet));
         if n > MAX_PORT {
             return Err(PacketReadError::InvalidU16Error(n))
         }
@@ -231,7 +228,7 @@ impl ReadFromPacket for u16 {
 /// IPv4 addresses are serialized directly as 32-bit integers.
 impl ReadFromPacket for net::Ipv4Addr {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let ip: u32 = try!(packet.read_value());
+        let ip = try!(u32::read_from_packet(packet));
         Ok(net::Ipv4Addr::from(ip))
     }
 }
@@ -240,9 +237,11 @@ impl ReadFromPacket for net::Ipv4Addr {
 /// characters.
 impl ReadFromPacket for String {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let len = try!(packet.read_value());
+        let len = try!(usize::read_from_packet(packet));
+
         let mut buffer = vec![0; len];
-        try!(packet.read(&mut buffer));
+        try!(packet.read_exact(&mut buffer));
+
         match ISO_8859_1.decode(&buffer, DecoderTrap::Strict) {
             Ok(string) => Ok(string),
             Err(_) => Err(PacketReadError::InvalidStringError(buffer))
@@ -253,11 +252,13 @@ impl ReadFromPacket for String {
 /// Vectors are serialized as length-prefixed arrays of values.
 impl<T: ReadFromPacket> ReadFromPacket for Vec<T> {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        let len: usize = try!(packet.read_value());
+        let len = try!(usize::read_from_packet(packet));
+
         let mut vec = Vec::new();
         for _ in 0..len {
-            vec.push(try!(packet.read_value()));
+            vec.push(try!(T::read_from_packet(packet)));
         }
+
         Ok(vec)
     }
 }
@@ -269,35 +270,36 @@ impl<T: ReadFromPacket> ReadFromPacket for Vec<T> {
 /// This trait is implemented by types that can be serialized to a binary
 /// MutPacket.
 pub trait WriteToPacket {
-    fn write_to_packet(self, &mut MutPacket) -> io::Result<()>;
+    fn write_to_packet(&self, &mut MutPacket) -> io::Result<()>;
 }
 
 /// 32-bit integers are serialized in 4 bytes, little-endian.
 impl WriteToPacket for u32 {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
-        packet.write_u32::<LittleEndian>(self)
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
+        packet.write_u32::<LittleEndian>(*self)
     }
 }
 
 /// Booleans are serialized as single bytes, containing either 0 or 1.
 impl WriteToPacket for bool {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write(&[self as u8]));
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
+        try!(packet.write_u8(*self as u8));
         Ok(())
     }
 }
 
 /// 16-bit integers are serialized as 32-bit integers.
 impl WriteToPacket for u16 {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
-        (self as u32).write_to_packet(packet)
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
+        (*self as u32).write_to_packet(packet)
     }
 }
 
 /// Strings are serialized as a length-prefixed array of ISO-8859-1 encoded
 /// characters.
-impl<'a> WriteToPacket for &'a str {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for str {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
+        // Encode the string.
         let bytes = match ISO_8859_1.encode(self, EncoderTrap::Strict) {
             Ok(bytes) => bytes,
             Err(_) => {
@@ -305,15 +307,16 @@ impl<'a> WriteToPacket for &'a str {
                 return Err(io::Error::new(io::ErrorKind::Other, copy))
             }
         };
-        try!(packet.write_value(bytes.len() as u32));
+        // Then write the bytes to the packet.
+        try!((bytes.len() as u32).write_to_packet(packet));
         try!(packet.write(&bytes));
         Ok(())
     }
 }
 
 /// Deref coercion does not happen for trait methods apparently.
-impl<'a> WriteToPacket for &'a String {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
-        packet.write_value::<&'a str>(self)
+impl WriteToPacket for String {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
+        (self as &str).write_to_packet(packet)
     }
 }

src/proto/server/request.rs

@@ -22,45 +22,45 @@ pub enum ServerRequest {
     UserStatusRequest(UserStatusRequest),
 }
 
-impl<'a> WriteToPacket for &'a ServerRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for ServerRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         match *self {
             ServerRequest::LoginRequest(ref request) => {
-                try!(packet.write_value(CODE_LOGIN));
+                try!(packet.write_value(&CODE_LOGIN));
                 try!(packet.write_value(request));
             },
 
             ServerRequest::PeerAddressRequest(ref request) => {
-                try!(packet.write_value(CODE_PEER_ADDRESS));
+                try!(packet.write_value(&CODE_PEER_ADDRESS));
                 try!(packet.write_value(request));
             },
 
             ServerRequest::RoomJoinRequest(ref request) => {
-                try!(packet.write_value(CODE_ROOM_JOIN));
+                try!(packet.write_value(&CODE_ROOM_JOIN));
                 try!(packet.write_value(request));
             },
 
             ServerRequest::RoomLeaveRequest(ref request) => {
-                try!(packet.write_value(CODE_ROOM_LEAVE));
+                try!(packet.write_value(&CODE_ROOM_LEAVE));
                 try!(packet.write_value(request));
             },
 
             ServerRequest::RoomListRequest => {
-                try!(packet.write_value(CODE_ROOM_LIST));
+                try!(packet.write_value(&CODE_ROOM_LIST));
             },
 
             ServerRequest::RoomMessageRequest(ref request) => {
-                try!(packet.write_value(CODE_ROOM_MESSAGE));
+                try!(packet.write_value(&CODE_ROOM_MESSAGE));
                 try!(packet.write_value(request));
             },
 
             ServerRequest::SetListenPortRequest(ref request) => {
-                try!(packet.write_value(CODE_SET_LISTEN_PORT));
+                try!(packet.write_value(&CODE_SET_LISTEN_PORT));
                 try!(packet.write_value(request));
             },
 
             ServerRequest::UserStatusRequest(ref request) => {
-                try!(packet.write_value(CODE_USER_STATUS));
+                try!(packet.write_value(&CODE_USER_STATUS));
                 try!(packet.write_value(request));
             }
         }
@@ -102,16 +102,16 @@ impl LoginRequest {
     }
 }
 
-impl<'a> WriteToPacket for &'a LoginRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for LoginRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         let userpass = String::new() + &self.username + &self.password;
         let userpass_md5 = md5_str(&userpass);
 
         try!(packet.write_value(&self.username));
         try!(packet.write_value(&self.password));
-        try!(packet.write_value(self.major));
+        try!(packet.write_value(&self.major));
         try!(packet.write_value(&userpass_md5));
-        try!(packet.write_value(self.minor));
+        try!(packet.write_value(&self.minor));
 
         Ok(())
     }
@@ -126,8 +126,8 @@ pub struct PeerAddressRequest {
     pub username: String,
 }
 
-impl<'a> WriteToPacket for &'a PeerAddressRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for PeerAddressRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         try!(packet.write_value(&self.username));
         Ok(())
     }
@@ -142,8 +142,8 @@ pub struct RoomJoinRequest {
     pub room_name: String
 }
 
-impl<'a> WriteToPacket for &'a RoomJoinRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for RoomJoinRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         try!(packet.write_value(&self.room_name));
         Ok(())
     }
@@ -158,8 +158,8 @@ pub struct RoomLeaveRequest {
     pub room_name: String
 }
 
-impl<'a> WriteToPacket for &'a RoomLeaveRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for RoomLeaveRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         try!(packet.write_value(&self.room_name));
         Ok(())
     }
@@ -175,8 +175,8 @@ pub struct RoomMessageRequest {
     pub message:   String,
 }
 
-impl<'a> WriteToPacket for &'a RoomMessageRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for RoomMessageRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         try!(packet.write_value(&self.room_name));
         try!(packet.write_value(&self.message));
         Ok(())
@@ -192,9 +192,9 @@ pub struct SetListenPortRequest {
     pub port: u16,
 }
 
-impl<'a> WriteToPacket for &'a SetListenPortRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
-        try!(packet.write_value(self.port));
+impl WriteToPacket for SetListenPortRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
+        try!(packet.write_value(&self.port));
         Ok(())
     }
 }
@@ -208,8 +208,8 @@ pub struct UserStatusRequest {
     pub user_name: String,
 }
 
-impl<'a> WriteToPacket for &'a UserStatusRequest {
-    fn write_to_packet(self, packet: &mut MutPacket) -> io::Result<()> {
+impl WriteToPacket for UserStatusRequest {
+    fn write_to_packet(&self, packet: &mut MutPacket) -> io::Result<()> {
         try!(packet.write_value(&self.user_name));
         Ok(())
     }

src/proto/stream.rs

@@ -277,7 +277,7 @@ impl<T, U> Stream<T, U>
     }
 
     /// The stream has been notified.
-    pub fn on_notify<V>(&mut self, payload: V) -> Intent
+    pub fn on_notify<V>(&mut self, payload: &V) -> Intent
         where V: WriteToPacket
     {
         let mut packet = MutPacket::new();

src/user.rs

@@ -36,14 +36,14 @@ impl proto::ReadFromPacket for Status {
     }
 }
 
-impl<'a> proto::WriteToPacket for &'a Status {
-    fn write_to_packet(self, packet: &mut proto::MutPacket) -> io::Result<()> {
+impl proto::WriteToPacket for Status {
+    fn write_to_packet(&self, packet: &mut proto::MutPacket) -> io::Result<()> {
         let n = match *self {
             Status::Offline => STATUS_OFFLINE,
             Status::Away    => STATUS_AWAY,
             Status::Online  => STATUS_ONLINE,
         };
-        try!(packet.write_value(n));
+        try!(packet.write_value(&n));
         Ok(())
     }
 }