Rename Proto{En,De}code to Value{En,De}code.

src/proto/base_codec.rs

@@ -40,7 +40,7 @@ pub trait Encode<T> {
 // TODO: Add backtrace fields to each enum variant once std::backtrace is
 // stabilized.
 #[derive(PartialEq, Error, Debug)]
-pub enum ProtoDecodeError {
+pub enum ValueDecodeError {
     #[error("at position {position}: not enough bytes to decode: expected {expected}, found {remaining}")]
     NotEnoughData {
         /// The number of bytes the decoder expected to read.
@@ -93,10 +93,10 @@ pub enum ProtoDecodeError {
     },
 }
 
-impl From<ProtoDecodeError> for io::Error {
-    fn from(error: ProtoDecodeError) -> Self {
+impl From<ValueDecodeError> for io::Error {
+    fn from(error: ValueDecodeError) -> Self {
         let kind = match &error {
-            &ProtoDecodeError::NotEnoughData { .. } => io::ErrorKind::UnexpectedEof,
+            &ValueDecodeError::NotEnoughData { .. } => io::ErrorKind::UnexpectedEof,
             _ => io::ErrorKind::InvalidData,
         };
         let message = format!("{}", &error);
@@ -105,7 +105,7 @@ impl From<ProtoDecodeError> for io::Error {
 }
 
 /// A type for decoding various types of values from protocol messages.
-pub struct ProtoDecoder<'a> {
+pub struct ValueDecoder<'a> {
     // The buffer we are decoding from.
     //
     // Invariant: `position <= buffer.len()`.
@@ -123,13 +123,13 @@ pub struct ProtoDecoder<'a> {
 }
 
 /// This trait is implemented by types that can be decoded from messages using
-/// a `ProtoDecoder`.
-pub trait ProtoDecode: Sized {
+/// a `ValueDecoder`.
+pub trait ValueDecode: Sized {
     /// Attempts to decode a value of this type with the given decoder.
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError>;
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError>;
 }
 
-impl<'a> ProtoDecoder<'a> {
+impl<'a> ValueDecoder<'a> {
     /// Wraps the given byte buffer.
     pub fn new(buffer: &'a [u8]) -> Self {
         Self {
@@ -166,9 +166,9 @@ impl<'a> ProtoDecoder<'a> {
     ///
     /// Returns a slice of size `n` if successful, in which case this decoder
     /// advances its internal position by `n`.
-    fn consume(&mut self, n: usize) -> Result<&[u8], ProtoDecodeError> {
+    fn consume(&mut self, n: usize) -> Result<&[u8], ValueDecodeError> {
         if self.remaining() < n {
-            return Err(ProtoDecodeError::NotEnoughData {
+            return Err(ValueDecodeError::NotEnoughData {
                 expected: n,
                 remaining: self.remaining(),
                 position: self.position,
@@ -184,7 +184,7 @@ impl<'a> ProtoDecoder<'a> {
     }
 
     /// Attempts to decode a u32 value.
-    fn decode_u32(&mut self) -> Result<u32, ProtoDecodeError> {
+    fn decode_u32(&mut self) -> Result<u32, ValueDecodeError> {
         let bytes = self.consume(U32_BYTE_LEN)?;
         // The conversion from slice to fixed-size array cannot fail, because
         // consume() guarantees that its return value is of size n.
@@ -192,12 +192,12 @@ impl<'a> ProtoDecoder<'a> {
         Ok(u32::from_le_bytes(array))
     }
 
-    fn decode_u16(&mut self) -> Result<u16, ProtoDecodeError> {
+    fn decode_u16(&mut self) -> Result<u16, ValueDecodeError> {
         let position = self.position;
         let n = self.decode_u32()?;
         match u16::try_from(n) {
             Ok(value) => Ok(value),
-            Err(_) => Err(ProtoDecodeError::InvalidU16 {
+            Err(_) => Err(ValueDecodeError::InvalidU16 {
                 value: n,
                 position: position,
             }),
@@ -205,13 +205,13 @@ impl<'a> ProtoDecoder<'a> {
     }
 
     /// Attempts to decode a boolean value.
-    fn decode_bool(&mut self) -> Result<bool, ProtoDecodeError> {
+    fn decode_bool(&mut self) -> Result<bool, ValueDecodeError> {
         let position = self.position;
         let bytes = self.consume(1)?;
         match bytes[0] {
             0 => Ok(false),
             1 => Ok(true),
-            n => Err(ProtoDecodeError::InvalidBool {
+            n => Err(ValueDecodeError::InvalidBool {
                 value: n,
                 position: position,
             }),
@@ -219,7 +219,7 @@ impl<'a> ProtoDecoder<'a> {
     }
 
     /// Attempts to decode a string value.
-    fn decode_string(&mut self) -> Result<String, ProtoDecodeError> {
+    fn decode_string(&mut self) -> Result<String, ValueDecodeError> {
         let length = self.decode_u32()? as usize;
 
         let position = self.position;
@@ -228,7 +228,7 @@ impl<'a> ProtoDecoder<'a> {
         let result = WINDOWS_1252.decode(bytes, DecoderTrap::Strict);
         match result {
             Ok(string) => Ok(string),
-            Err(error) => Err(ProtoDecodeError::InvalidString {
+            Err(error) => Err(ValueDecodeError::InvalidString {
                 cause: error.to_string(),
                 position: position,
             }),
@@ -242,52 +242,52 @@ impl<'a> ProtoDecoder<'a> {
     /// ```
     /// let val: Foo = decoder.decode()?;
     /// ```
-    pub fn decode<T: ProtoDecode>(&mut self) -> Result<T, ProtoDecodeError> {
+    pub fn decode<T: ValueDecode>(&mut self) -> Result<T, ValueDecodeError> {
         T::decode_from(self)
     }
 }
 
-impl ProtoDecode for u32 {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for u32 {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         decoder.decode_u32()
     }
 }
 
-impl ProtoDecode for u16 {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for u16 {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         decoder.decode_u16()
     }
 }
 
-impl ProtoDecode for bool {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for bool {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         decoder.decode_bool()
     }
 }
 
-impl ProtoDecode for net::Ipv4Addr {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for net::Ipv4Addr {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let ip = decoder.decode_u32()?;
         Ok(net::Ipv4Addr::from(ip))
     }
 }
 
-impl ProtoDecode for String {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for String {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         decoder.decode_string()
     }
 }
 
-impl<T: ProtoDecode, U: ProtoDecode> ProtoDecode for (T, U) {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl<T: ValueDecode, U: ValueDecode> ValueDecode for (T, U) {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let first = decoder.decode()?;
         let second = decoder.decode()?;
         Ok((first, second))
     }
 }
 
-impl<T: ProtoDecode> ProtoDecode for Vec<T> {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl<T: ValueDecode> ValueDecode for Vec<T> {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let len = decoder.decode_u32()? as usize;
         let mut vec = Vec::with_capacity(len);
         for _ in 0..len {
@@ -299,7 +299,7 @@ impl<T: ProtoDecode> ProtoDecode for Vec<T> {
 }
 
 #[derive(Debug, Error, PartialEq)]
-pub enum ProtoEncodeError {
+pub enum ValueEncodeError {
     #[error("encoded string length {length} is too large: {string:?}")]
     StringTooLong {
         /// The string that is too long to encode.
@@ -311,53 +311,53 @@ pub enum ProtoEncodeError {
     },
 }
 
-impl From<ProtoEncodeError> for io::Error {
-    fn from(error: ProtoEncodeError) -> Self {
+impl From<ValueEncodeError> for io::Error {
+    fn from(error: ValueEncodeError) -> Self {
         io::Error::new(io::ErrorKind::InvalidData, format!("{}", error))
     }
 }
 
 /// A type for encoding various types of values into protocol messages.
-pub struct ProtoEncoder<'a> {
+pub struct ValueEncoder<'a> {
     /// The buffer to which the encoder appends encoded bytes.
     buffer: &'a mut Vec<u8>,
 }
 
 /// This trait is implemented by types that can be encoded into messages using
-/// a `ProtoEncoder`.
-pub trait ProtoEncode {
+/// a `ValueEncoder`.
+pub trait ValueEncode {
     // TODO: Rename to encode_to().
     /// Attempts to encode `self` with the given encoder.
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError>;
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError>;
 }
 
-impl<'a> ProtoEncoder<'a> {
+impl<'a> ValueEncoder<'a> {
     /// Wraps the given buffer for encoding values into.
     ///
     /// Encoded bytes are appended. The buffer is not pre-cleared.
     pub fn new(buffer: &'a mut Vec<u8>) -> Self {
-        ProtoEncoder { buffer: buffer }
+        ValueEncoder { buffer: buffer }
     }
 
     /// Encodes the given u32 value into the underlying buffer.
-    pub fn encode_u32(&mut self, val: u32) -> Result<(), ProtoEncodeError> {
+    pub fn encode_u32(&mut self, val: u32) -> Result<(), ValueEncodeError> {
         self.buffer.extend_from_slice(&val.to_le_bytes());
         Ok(())
     }
 
     /// Encodes the given u16 value into the underlying buffer.
-    pub fn encode_u16(&mut self, val: u16) -> Result<(), ProtoEncodeError> {
+    pub fn encode_u16(&mut self, val: u16) -> Result<(), ValueEncodeError> {
         self.encode_u32(val as u32)
     }
 
     /// Encodes the given boolean value into the underlying buffer.
-    pub fn encode_bool(&mut self, val: bool) -> Result<(), ProtoEncodeError> {
+    pub fn encode_bool(&mut self, val: bool) -> Result<(), ValueEncodeError> {
         self.buffer.push(val as u8);
         Ok(())
     }
 
     /// Encodes the given string into the underlying buffer.
-    pub fn encode_string(&mut self, val: &str) -> Result<(), ProtoEncodeError> {
+    pub fn encode_string(&mut self, val: &str) -> Result<(), ValueEncodeError> {
         // Record where we were when we started. This is where we will write
         // the length prefix once we are done encoding the string. Until then
         // we do not know how many bytes are needed to encode the string.
@@ -377,7 +377,7 @@ impl<'a> ProtoEncoder<'a> {
         let length_u32 = match u32::try_from(length) {
             Ok(value) => value,
             Err(_) => {
-                return Err(ProtoEncodeError::StringTooLong {
+                return Err(ValueEncodeError::StringTooLong {
                     string: val.to_string(),
                     length: length,
                 })
@@ -396,31 +396,31 @@ impl<'a> ProtoEncoder<'a> {
     /// ```
     /// encoder.encode(&Foo::new(bar))?;
     /// ```
-    pub fn encode<T: ProtoEncode>(&mut self, val: &T) -> Result<(), ProtoEncodeError> {
+    pub fn encode<T: ValueEncode>(&mut self, val: &T) -> Result<(), ValueEncodeError> {
         val.encode(self)
     }
 }
 
-impl ProtoEncode for u32 {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for u32 {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(*self)
     }
 }
 
-impl ProtoEncode for u16 {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for u16 {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u16(*self)
     }
 }
 
-impl ProtoEncode for bool {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for bool {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_bool(*self)
     }
 }
 
-impl ProtoEncode for net::Ipv4Addr {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for net::Ipv4Addr {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(u32::from(*self))
     }
 }
@@ -433,33 +433,33 @@ impl ProtoEncode for net::Ipv4Addr {
 // wrapping primitive types in a newtype for which we implement
 // Proto{De,En}code) but it is not really worth the hassle.
 
-impl ProtoEncode for str {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for str {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(self)
     }
 }
 
-impl ProtoEncode for String {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for String {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(self)
     }
 }
 
-impl<'a> ProtoEncode for &'a String {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl<'a> ValueEncode for &'a String {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(*self)
     }
 }
 
-impl<T: ProtoEncode, U: ProtoEncode> ProtoEncode for (T, U) {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+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)
     }
 }
 
-impl<T: ProtoEncode> ProtoEncode for [T] {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl<T: ValueEncode> ValueEncode for [T] {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.len() as u32)?;
         for ref item in self {
             item.encode(encoder)?;
@@ -468,8 +468,8 @@ impl<T: ProtoEncode> ProtoEncode for [T] {
     }
 }
 
-impl<T: ProtoEncode> ProtoEncode for Vec<T> {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl<T: ValueEncode> ValueEncode for Vec<T> {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         let slice: &[T] = &*self;
         slice.encode(encoder)
     }
@@ -487,19 +487,19 @@ pub mod tests {
     use std::u16;
     use std::u32;
 
-    use super::{ProtoDecode, ProtoDecodeError, ProtoDecoder, ProtoEncode, ProtoEncoder};
+    use super::{ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncoder};
 
     // Declared here because assert_eq!(bytes, &[]) fails to infer types.
     const EMPTY_BYTES: &'static [u8] = &[];
 
     pub fn roundtrip<T>(input: T)
     where
-        T: fmt::Debug + Eq + PartialEq + ProtoEncode + ProtoDecode,
+        T: fmt::Debug + Eq + PartialEq + ValueEncode + ValueDecode,
     {
         let mut bytes = vec![];
 
-        ProtoEncoder::new(&mut bytes).encode(&input).unwrap();
-        let output = ProtoDecoder::new(&bytes).decode::<T>().unwrap();
+        ValueEncoder::new(&mut bytes).encode(&input).unwrap();
+        let output = ValueDecoder::new(&bytes).decode::<T>().unwrap();
 
         assert_eq!(output, input);
     }
@@ -523,7 +523,7 @@ pub mod tests {
             let mut expected_bytes = vec![13];
             expected_bytes.extend(encoded_bytes);
 
-            ProtoEncoder::new(&mut bytes).encode_u32(val).unwrap();
+            ValueEncoder::new(&mut bytes).encode_u32(val).unwrap();
             assert_eq!(bytes, expected_bytes);
         }
     }
@@ -532,7 +532,7 @@ pub mod tests {
     fn decode_u32() {
         for &(expected_val, ref bytes) in &U32_ENCODINGS {
             let buffer = bytes.to_vec();
-            let mut decoder = ProtoDecoder::new(&buffer);
+            let mut decoder = ValueDecoder::new(&buffer);
 
             let val = decoder.decode::<u32>().unwrap();
 
@@ -551,13 +551,13 @@ pub mod tests {
     #[test]
     fn decode_u32_unexpected_eof() {
         let buffer = vec![13];
-        let mut decoder = ProtoDecoder::new(&buffer);
+        let mut decoder = ValueDecoder::new(&buffer);
 
         let result = decoder.decode::<u32>();
 
         assert_eq!(
             result,
-            Err(ProtoDecodeError::NotEnoughData {
+            Err(ValueDecodeError::NotEnoughData {
                 expected: 4,
                 remaining: 1,
                 position: 0,
@@ -569,21 +569,21 @@ pub mod tests {
     #[test]
     fn encode_bool_false() {
         let mut bytes = vec![13];
-        ProtoEncoder::new(&mut bytes).encode_bool(false).unwrap();
+        ValueEncoder::new(&mut bytes).encode_bool(false).unwrap();
         assert_eq!(bytes, vec![13, 0]);
     }
 
     #[test]
     fn encode_bool_true() {
         let mut bytes = vec![13];
-        ProtoEncoder::new(&mut bytes).encode_bool(true).unwrap();
+        ValueEncoder::new(&mut bytes).encode_bool(true).unwrap();
         assert_eq!(bytes, vec![13, 1]);
     }
 
     #[test]
     fn decode_bool_false() {
         let buffer = vec![0];
-        let mut decoder = ProtoDecoder::new(&buffer);
+        let mut decoder = ValueDecoder::new(&buffer);
 
         let val = decoder.decode::<bool>().unwrap();
 
@@ -594,7 +594,7 @@ pub mod tests {
     #[test]
     fn decode_bool_true() {
         let buffer = vec![1];
-        let mut decoder = ProtoDecoder::new(&buffer);
+        let mut decoder = ValueDecoder::new(&buffer);
 
         let val = decoder.decode::<bool>().unwrap();
 
@@ -606,11 +606,11 @@ pub mod tests {
     fn decode_bool_invalid() {
         let buffer = vec![42];
 
-        let result = ProtoDecoder::new(&buffer).decode::<bool>();
+        let result = ValueDecoder::new(&buffer).decode::<bool>();
 
         assert_eq!(
             result,
-            Err(ProtoDecodeError::InvalidBool {
+            Err(ValueDecodeError::InvalidBool {
                 value: 42,
                 position: 0,
             })
@@ -621,11 +621,11 @@ pub mod tests {
     fn decode_bool_unexpected_eof() {
         let buffer = vec![];
 
-        let result = ProtoDecoder::new(&buffer).decode::<bool>();
+        let result = ValueDecoder::new(&buffer).decode::<bool>();
 
         assert_eq!(
             result,
-            Err(ProtoDecodeError::NotEnoughData {
+            Err(ValueDecodeError::NotEnoughData {
                 expected: 1,
                 remaining: 0,
                 position: 0,
@@ -650,7 +650,7 @@ pub mod tests {
             let mut expected_bytes = vec![13];
             expected_bytes.extend(encoded_bytes);
 
-            ProtoEncoder::new(&mut bytes).encode(&(val as u16)).unwrap();
+            ValueEncoder::new(&mut bytes).encode(&(val as u16)).unwrap();
             assert_eq!(bytes, expected_bytes);
         }
     }
@@ -658,7 +658,7 @@ pub mod tests {
     #[test]
     fn decode_u16() {
         for &(expected_val, ref buffer) in &U32_ENCODINGS {
-            let mut decoder = ProtoDecoder::new(buffer);
+            let mut decoder = ValueDecoder::new(buffer);
 
             if expected_val <= u16::MAX as u32 {
                 let val = decoder.decode::<u16>().unwrap();
@@ -667,7 +667,7 @@ pub mod tests {
             } else {
                 assert_eq!(
                     decoder.decode::<u16>(),
-                    Err(ProtoDecodeError::InvalidU16 {
+                    Err(ValueDecodeError::InvalidU16 {
                         value: expected_val,
                         position: 0,
                     })
@@ -679,13 +679,13 @@ pub mod tests {
     #[test]
     fn decode_u16_unexpected_eof() {
         let buffer = vec![];
-        let mut decoder = ProtoDecoder::new(&buffer);
+        let mut decoder = ValueDecoder::new(&buffer);
 
         let result = decoder.decode::<u16>();
 
         assert_eq!(
             result,
-            Err(ProtoDecodeError::NotEnoughData {
+            Err(ValueDecodeError::NotEnoughData {
                 expected: 4,
                 remaining: 0,
                 position: 0,
@@ -710,7 +710,7 @@ pub mod tests {
             expected_bytes.extend(encoded_bytes);
 
             let addr = net::Ipv4Addr::from(val);
-            ProtoEncoder::new(&mut bytes).encode(&addr).unwrap();
+            ValueEncoder::new(&mut bytes).encode(&addr).unwrap();
             assert_eq!(bytes, expected_bytes);
         }
     }
@@ -718,7 +718,7 @@ pub mod tests {
     #[test]
     fn decode_ipv4() {
         for &(expected_val, ref buffer) in &U32_ENCODINGS {
-            let mut decoder = ProtoDecoder::new(buffer);
+            let mut decoder = ValueDecoder::new(buffer);
 
             let val = decoder.decode::<net::Ipv4Addr>().unwrap();
 
@@ -749,7 +749,7 @@ pub mod tests {
             let mut expected_bytes = vec![13];
             expected_bytes.extend(encoded_bytes);
 
-            ProtoEncoder::new(&mut bytes).encode_string(string).unwrap();
+            ValueEncoder::new(&mut bytes).encode_string(string).unwrap();
             assert_eq!(bytes, expected_bytes);
         }
     }
@@ -758,20 +758,20 @@ pub mod tests {
     fn encode_string_with_unencodable_characters() {
         let mut bytes = vec![];
 
-        ProtoEncoder::new(&mut bytes)
+        ValueEncoder::new(&mut bytes)
             .encode_string("忠犬ハチ公")
             .unwrap();
 
         // Characters not in the Windows 1252 codepage are rendered as '?'.
         assert_eq!(bytes, &[5, 0, 0, 0, 63, 63, 63, 63, 63]);
 
-        assert_eq!(ProtoDecoder::new(&bytes).decode_string().unwrap(), "?????");
+        assert_eq!(ValueDecoder::new(&bytes).decode_string().unwrap(), "?????");
     }
 
     #[test]
     fn decode_string() {
         for &(expected_string, buffer) in &STRING_ENCODINGS {
-            let mut decoder = ProtoDecoder::new(&buffer);
+            let mut decoder = ValueDecoder::new(&buffer);
 
             let string = decoder.decode::<String>().unwrap();
 
@@ -798,7 +798,7 @@ pub mod tests {
         expected_bytes.extend(expected_integer_bytes);
         expected_bytes.extend(expected_string_bytes);
 
-        ProtoEncoder::new(&mut bytes)
+        ValueEncoder::new(&mut bytes)
             .encode(&(integer, string.to_string()))
             .unwrap();
 
@@ -815,7 +815,7 @@ pub mod tests {
         buffer.extend(integer_bytes);
         buffer.extend(string_bytes);
 
-        let mut decoder = ProtoDecoder::new(&buffer);
+        let mut decoder = ValueDecoder::new(&buffer);
 
         let pair = decoder.decode::<(u32, String)>().unwrap();
 
@@ -838,7 +838,7 @@ pub mod tests {
         }
 
         let mut bytes = vec![13];
-        ProtoEncoder::new(&mut bytes).encode(&vec).unwrap();
+        ValueEncoder::new(&mut bytes).encode(&vec).unwrap();
 
         assert_eq!(bytes, expected_bytes);
     }
@@ -852,7 +852,7 @@ pub mod tests {
             buffer.extend(encoded_bytes);
         }
 
-        let mut decoder = ProtoDecoder::new(&buffer);
+        let mut decoder = ValueDecoder::new(&buffer);
 
         let vec = decoder.decode::<Vec<u32>>().unwrap();
 

src/proto/codec.rs

@@ -17,11 +17,11 @@ use std::marker;
 use bytes::BytesMut;
 use tokio_codec;
 
-use super::base_codec::{ProtoDecode, ProtoDecoder, ProtoEncode, ProtoEncoder, U32_BYTE_LEN};
+use super::base_codec::{ValueDecode, ValueDecoder, ValueEncode, ValueEncoder, U32_BYTE_LEN};
 use super::peer::Message;
 use super::server::{ServerRequest, ServerResponse};
 
-/// Implements tokio's Encoder trait for types that implement ProtoEncode.
+/// Implements tokio's Encoder trait for types that implement ValueEncode.
 pub struct LengthPrefixedEncoder<T> {
     phantom: marker::PhantomData<T>,
 }
@@ -34,7 +34,7 @@ impl<T> LengthPrefixedEncoder<T> {
     }
 }
 
-impl<T: ProtoEncode> tokio_codec::Encoder for LengthPrefixedEncoder<T> {
+impl<T: ValueEncode> tokio_codec::Encoder for LengthPrefixedEncoder<T> {
     type Item = T;
     type Error = io::Error;
 
@@ -43,11 +43,11 @@ impl<T: ProtoEncode> tokio_codec::Encoder for LengthPrefixedEncoder<T> {
         // Note that this is ugly right now, but will get better once we switch
         // off of Tokio and onto regular futures.
         let mut buffer = vec![];
-        ProtoEncoder::new(&mut buffer).encode(&item)?;
+        ValueEncoder::new(&mut buffer).encode(&item)?;
 
         // Encode the message length.
         let mut prefix = vec![];
-        ProtoEncoder::new(&mut prefix).encode_u32(buffer.len() as u32)?;
+        ValueEncoder::new(&mut prefix).encode_u32(buffer.len() as u32)?;
 
         dst.reserve(prefix.len() + buffer.len());
         dst.extend_from_slice(&prefix);
@@ -56,7 +56,7 @@ impl<T: ProtoEncode> tokio_codec::Encoder for LengthPrefixedEncoder<T> {
     }
 }
 
-/// Implements tokio's Decoder trait for types that implement ProtoDecode.
+/// Implements tokio's Decoder trait for types that implement ValueDecode.
 pub struct LengthPrefixedDecoder<T> {
     // The length, as a number of bytes, of the next item to decode.
     // None if we have not read the length prefix yet.
@@ -95,14 +95,14 @@ impl<T> LengthPrefixedDecoder<T> {
         }
 
         let prefix = src.split_to(U32_BYTE_LEN);
-        let length = ProtoDecoder::new(&prefix).decode::<u32>()?;
+        let length = ValueDecoder::new(&prefix).decode::<u32>()?;
 
         self.length = Some(length as usize);
         Ok(())
     }
 }
 
-impl<T: ProtoDecode> tokio_codec::Decoder for LengthPrefixedDecoder<T> {
+impl<T: ValueDecode> tokio_codec::Decoder for LengthPrefixedDecoder<T> {
     type Item = T;
     type Error = io::Error;
 
@@ -124,7 +124,7 @@ impl<T: ProtoDecode> tokio_codec::Decoder for LengthPrefixedDecoder<T> {
         self.length = None;
 
         // Attempt to decode the value.
-        let item = ProtoDecoder::new(&buf).decode()?;
+        let item = ValueDecoder::new(&buf).decode()?;
         Ok(Some(item))
     }
 }
@@ -133,7 +133,7 @@ mod tests {
     use bytes::BytesMut;
     use tokio_codec::{Decoder, Encoder};
 
-    use crate::proto::ProtoEncode;
+    use crate::proto::ValueEncode;
 
     use super::{LengthPrefixedDecoder, LengthPrefixedEncoder};
 

src/proto/mod.rs

@@ -9,8 +9,8 @@ mod stream;
 mod user;
 
 pub use self::base_codec::{
-    Decode, ProtoDecode, ProtoDecodeError, ProtoDecoder, ProtoEncode, ProtoEncodeError,
-    ProtoEncoder,
+    Decode, ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
+    ValueEncoder,
 };
 pub use self::codec::*;
 pub use self::handler::*;

src/proto/peer/message.rs

@@ -2,8 +2,8 @@ use std::io;
 
 use crate::proto::peer::constants::*;
 use crate::proto::{
-    MutPacket, Packet, PacketReadError, ProtoDecode, ProtoDecodeError, ProtoDecoder, ProtoEncode,
-    ProtoEncodeError, ProtoEncoder, ReadFromPacket, WriteToPacket,
+    MutPacket, Packet, PacketReadError, ReadFromPacket, ValueDecode, ValueDecodeError,
+    ValueDecoder, ValueEncode, ValueEncodeError, ValueEncoder, WriteToPacket,
 };
 
 /*=========*
@@ -41,8 +41,8 @@ impl ReadFromPacket for Message {
     }
 }
 
-impl ProtoDecode for Message {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for Message {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let code: u32 = decoder.decode()?;
         let message = match code {
@@ -55,7 +55,7 @@ impl ProtoDecode for Message {
                 Message::PeerInit(peer_init)
             }
             _ => {
-                return Err(ProtoDecodeError::InvalidData {
+                return Err(ValueDecodeError::InvalidData {
                     value_name: "peer message code".to_string(),
                     cause: format!("unknown value {}", code),
                     position: position,
@@ -66,8 +66,8 @@ impl ProtoDecode for Message {
     }
 }
 
-impl ProtoEncode for Message {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for Message {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         match *self {
             Message::PierceFirewall(token) => {
                 encoder.encode_u32(CODE_PIERCE_FIREWALL)?;
@@ -131,8 +131,8 @@ impl WriteToPacket for PeerInit {
     }
 }
 
-impl ProtoEncode for PeerInit {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for PeerInit {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)?;
         encoder.encode_string(&self.connection_type)?;
         encoder.encode_u32(self.token)?;
@@ -140,8 +140,8 @@ impl ProtoEncode for PeerInit {
     }
 }
 
-impl ProtoDecode for PeerInit {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for PeerInit {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let connection_type = decoder.decode()?;
         let token = decoder.decode()?;
@@ -160,7 +160,7 @@ mod tests {
     use bytes::BytesMut;
 
     use crate::proto::base_codec::tests::roundtrip;
-    use crate::proto::{ProtoDecodeError, ProtoDecoder};
+    use crate::proto::{ValueDecodeError, ValueDecoder};
 
     use super::*;
 
@@ -168,11 +168,11 @@ mod tests {
     fn invalid_code() {
         let bytes = BytesMut::from(vec![57, 5, 0, 0]);
 
-        let result = ProtoDecoder::new(&bytes).decode::<Message>();
+        let result = ValueDecoder::new(&bytes).decode::<Message>();
 
         assert_eq!(
             result,
-            Err(ProtoDecodeError::InvalidData {
+            Err(ValueDecodeError::InvalidData {
                 value_name: "peer message code".to_string(),
                 cause: "unknown value 1337".to_string(),
                 position: 0,

src/proto/server/request.rs

@@ -6,7 +6,7 @@ use crypto::md5::Md5;
 use crate::proto::packet::{MutPacket, WriteToPacket};
 use crate::proto::server::constants::*;
 use crate::proto::{
-    ProtoDecode, ProtoDecodeError, ProtoDecoder, ProtoEncode, ProtoEncodeError, ProtoEncoder,
+    ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError, ValueEncoder,
 };
 
 /* ------- *
@@ -99,8 +99,8 @@ impl WriteToPacket for ServerRequest {
     }
 }
 
-impl ProtoEncode for ServerRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for ServerRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         match *self {
             ServerRequest::CannotConnectRequest(ref request) => {
                 encoder.encode_u32(CODE_CANNOT_CONNECT)?;
@@ -150,8 +150,8 @@ impl ProtoEncode for ServerRequest {
     }
 }
 
-impl ProtoDecode for ServerRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for ServerRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let code: u32 = decoder.decode()?;
         let request = match code {
@@ -197,7 +197,7 @@ impl ProtoDecode for ServerRequest {
                 ServerRequest::UserStatusRequest(request)
             }
             _ => {
-                return Err(ProtoDecodeError::InvalidData {
+                return Err(ValueDecodeError::InvalidData {
                     value_name: "server request code".to_string(),
                     cause: format!("unknown value {}", code),
                     position: position,
@@ -226,15 +226,15 @@ impl WriteToPacket for CannotConnectRequest {
     }
 }
 
-impl ProtoEncode for CannotConnectRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for CannotConnectRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.token)?;
         encoder.encode_string(&self.user_name)
     }
 }
 
-impl ProtoDecode for CannotConnectRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for CannotConnectRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let token = decoder.decode()?;
         let user_name = decoder.decode()?;
         Ok(CannotConnectRequest { token, user_name })
@@ -261,16 +261,16 @@ impl WriteToPacket for ConnectToPeerRequest {
     }
 }
 
-impl ProtoEncode for ConnectToPeerRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for ConnectToPeerRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.token)?;
         encoder.encode_string(&self.user_name)?;
         encoder.encode_string(&self.connection_type)
     }
 }
 
-impl ProtoDecode for ConnectToPeerRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for ConnectToPeerRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let token = decoder.decode()?;
         let user_name = decoder.decode()?;
         let connection_type = decoder.decode()?;
@@ -300,15 +300,15 @@ impl WriteToPacket for FileSearchRequest {
     }
 }
 
-impl ProtoEncode for FileSearchRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for FileSearchRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.ticket)?;
         encoder.encode_string(&self.query)
     }
 }
 
-impl ProtoDecode for FileSearchRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for FileSearchRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let ticket = decoder.decode()?;
         let query = decoder.decode()?;
         Ok(FileSearchRequest { ticket, query })
@@ -369,8 +369,8 @@ impl WriteToPacket for LoginRequest {
     }
 }
 
-impl ProtoEncode for LoginRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for LoginRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.username)?;
         encoder.encode_string(&self.password)?;
         encoder.encode_u32(self.major)?;
@@ -379,8 +379,8 @@ impl ProtoEncode for LoginRequest {
     }
 }
 
-impl ProtoDecode for LoginRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for LoginRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let username = decoder.decode()?;
         let password = decoder.decode()?;
         let major = decoder.decode()?;
@@ -412,14 +412,14 @@ impl WriteToPacket for PeerAddressRequest {
     }
 }
 
-impl ProtoEncode for PeerAddressRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for PeerAddressRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.username)
     }
 }
 
-impl ProtoDecode for PeerAddressRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for PeerAddressRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let username = decoder.decode()?;
         Ok(PeerAddressRequest { username: username })
     }
@@ -441,14 +441,14 @@ impl WriteToPacket for RoomJoinRequest {
     }
 }
 
-impl ProtoEncode for RoomJoinRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomJoinRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)
     }
 }
 
-impl ProtoDecode for RoomJoinRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomJoinRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         Ok(RoomJoinRequest {
             room_name: room_name,
@@ -472,14 +472,14 @@ impl WriteToPacket for RoomLeaveRequest {
     }
 }
 
-impl ProtoEncode for RoomLeaveRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomLeaveRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)
     }
 }
 
-impl ProtoDecode for RoomLeaveRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomLeaveRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         Ok(RoomLeaveRequest {
             room_name: room_name,
@@ -505,15 +505,15 @@ impl WriteToPacket for RoomMessageRequest {
     }
 }
 
-impl ProtoEncode for RoomMessageRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomMessageRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.message)
     }
 }
 
-impl ProtoDecode for RoomMessageRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomMessageRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let message = decoder.decode()?;
         Ok(RoomMessageRequest { room_name, message })
@@ -536,14 +536,14 @@ impl WriteToPacket for SetListenPortRequest {
     }
 }
 
-impl ProtoEncode for SetListenPortRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for SetListenPortRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.port)
     }
 }
 
-impl ProtoDecode for SetListenPortRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for SetListenPortRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let port = decoder.decode()?;
         Ok(SetListenPortRequest { port: port })
     }
@@ -565,14 +565,14 @@ impl WriteToPacket for UserStatusRequest {
     }
 }
 
-impl ProtoEncode for UserStatusRequest {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for UserStatusRequest {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)
     }
 }
 
-impl ProtoDecode for UserStatusRequest {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for UserStatusRequest {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         Ok(UserStatusRequest {
             user_name: user_name,
@@ -591,7 +591,7 @@ mod tests {
     use bytes::BytesMut;
 
     use crate::proto::base_codec::tests::roundtrip;
-    use crate::proto::{ProtoDecodeError, ProtoDecoder};
+    use crate::proto::{ValueDecodeError, ValueDecoder};
 
     use super::*;
 
@@ -599,11 +599,11 @@ mod tests {
     fn invalid_code() {
         let bytes = BytesMut::from(vec![57, 5, 0, 0]);
 
-        let result = ProtoDecoder::new(&bytes).decode::<ServerRequest>();
+        let result = ValueDecoder::new(&bytes).decode::<ServerRequest>();
 
         assert_eq!(
             result,
-            Err(ProtoDecodeError::InvalidData {
+            Err(ValueDecodeError::InvalidData {
                 value_name: "server request code".to_string(),
                 cause: "unknown value 1337".to_string(),
                 position: 0,

src/proto/server/response.rs

@@ -4,8 +4,8 @@ use std::net;
 use crate::proto::packet::{Packet, PacketReadError, ReadFromPacket};
 use crate::proto::server::constants::*;
 use crate::proto::{
-    ProtoDecode, ProtoDecodeError, ProtoDecoder, ProtoEncode, ProtoEncodeError, ProtoEncoder, User,
-    UserStatus,
+    User, UserStatus, ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
+    ValueEncoder,
 };
 
 /*=================*
@@ -92,8 +92,8 @@ impl ReadFromPacket for ServerResponse {
     }
 }
 
-impl ProtoEncode for ServerResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for ServerResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         match *self {
             ServerResponse::ConnectToPeerResponse(ref response) => {
                 encoder.encode_u32(CODE_CONNECT_TO_PEER)?;
@@ -171,8 +171,8 @@ impl ProtoEncode for ServerResponse {
     }
 }
 
-impl ProtoDecode for ServerResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for ServerResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let code: u32 = decoder.decode()?;
         let response = match code {
@@ -245,7 +245,7 @@ impl ProtoDecode for ServerResponse {
                 ServerResponse::WishlistIntervalResponse(response)
             }
             _ => {
-                return Err(ProtoDecodeError::InvalidData {
+                return Err(ValueDecodeError::InvalidData {
                     value_name: "server response code".to_string(),
                     cause: format!("unknown value {}", code),
                     position: position,
@@ -290,8 +290,8 @@ impl ReadFromPacket for ConnectToPeerResponse {
     }
 }
 
-impl ProtoEncode for ConnectToPeerResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for ConnectToPeerResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.user_name)?;
         encoder.encode(&self.connection_type)?;
         encoder.encode(&self.ip)?;
@@ -301,8 +301,8 @@ impl ProtoEncode for ConnectToPeerResponse {
     }
 }
 
-impl ProtoDecode for ConnectToPeerResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for ConnectToPeerResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let connection_type = decoder.decode()?;
         let ip = decoder.decode()?;
@@ -346,16 +346,16 @@ impl ReadFromPacket for FileSearchResponse {
     }
 }
 
-impl ProtoEncode for FileSearchResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for FileSearchResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)?;
         encoder.encode_u32(self.ticket)?;
         encoder.encode_string(&self.query)
     }
 }
 
-impl ProtoDecode for FileSearchResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for FileSearchResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let ticket = decoder.decode()?;
         let query = decoder.decode()?;
@@ -409,8 +409,8 @@ impl ReadFromPacket for LoginResponse {
     }
 }
 
-impl ProtoEncode for LoginResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for LoginResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         match *self {
             LoginResponse::LoginOk {
                 ref motd,
@@ -430,8 +430,8 @@ impl ProtoEncode for LoginResponse {
     }
 }
 
-impl ProtoDecode for LoginResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for LoginResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let ok: bool = decoder.decode()?;
         if !ok {
             let reason = decoder.decode()?;
@@ -471,14 +471,14 @@ impl ReadFromPacket for ParentMinSpeedResponse {
     }
 }
 
-impl ProtoEncode for ParentMinSpeedResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for ParentMinSpeedResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.value)
     }
 }
 
-impl ProtoDecode for ParentMinSpeedResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for ParentMinSpeedResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let value = decoder.decode()?;
         Ok(ParentMinSpeedResponse { value })
     }
@@ -500,14 +500,14 @@ impl ReadFromPacket for ParentSpeedRatioResponse {
     }
 }
 
-impl ProtoEncode for ParentSpeedRatioResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for ParentSpeedRatioResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.value)
     }
 }
 
-impl ProtoDecode for ParentSpeedRatioResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for ParentSpeedRatioResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let value = decoder.decode()?;
         Ok(ParentSpeedRatioResponse { value })
     }
@@ -534,16 +534,16 @@ impl ReadFromPacket for PeerAddressResponse {
     }
 }
 
-impl ProtoEncode for PeerAddressResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for PeerAddressResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.username)?;
         encoder.encode(&self.ip)?;
         encoder.encode_u16(self.port)
     }
 }
 
-impl ProtoDecode for PeerAddressResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for PeerAddressResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let username = decoder.decode()?;
         let ip = decoder.decode()?;
         let port = decoder.decode()?;
@@ -567,14 +567,14 @@ impl ReadFromPacket for PrivilegedUsersResponse {
     }
 }
 
-impl ProtoEncode for PrivilegedUsersResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for PrivilegedUsersResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.users)
     }
 }
 
-impl ProtoDecode for PrivilegedUsersResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for PrivilegedUsersResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let users = decoder.decode()?;
         Ok(PrivilegedUsersResponse { users })
     }
@@ -727,8 +727,8 @@ fn build_user(
     }
 }
 
-impl ProtoEncode for UserInfo {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for UserInfo {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.average_speed)?;
         encoder.encode_u32(self.num_downloads)?;
         encoder.encode_u32(self.unknown)?;
@@ -737,8 +737,8 @@ impl ProtoEncode for UserInfo {
     }
 }
 
-impl ProtoDecode for UserInfo {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for UserInfo {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let average_speed = decoder.decode()?;
         let num_downloads = decoder.decode()?;
         let unknown = decoder.decode()?;
@@ -754,8 +754,8 @@ impl ProtoDecode for UserInfo {
     }
 }
 
-impl ProtoEncode for RoomJoinResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomJoinResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         let mut user_names = vec![];
         let mut user_statuses = vec![];
         let mut user_infos = vec![];
@@ -813,8 +813,8 @@ fn build_users(
     users
 }
 
-impl ProtoDecode for RoomJoinResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomJoinResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_names = decoder.decode()?;
         let user_statuses = decoder.decode()?;
@@ -863,14 +863,14 @@ impl ReadFromPacket for RoomLeaveResponse {
     }
 }
 
-impl ProtoEncode for RoomLeaveResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomLeaveResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)
     }
 }
 
-impl ProtoDecode for RoomLeaveResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomLeaveResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         Ok(RoomLeaveResponse { room_name })
     }
@@ -959,7 +959,7 @@ impl RoomListResponse {
         rooms
     }
 
-    fn decode_rooms(decoder: &mut ProtoDecoder) -> Result<Vec<(String, u32)>, ProtoDecodeError> {
+    fn decode_rooms(decoder: &mut ValueDecoder) -> Result<Vec<(String, u32)>, ValueDecodeError> {
         let room_names = decoder.decode()?;
         let user_counts = decoder.decode()?;
         Ok(Self::build_rooms(room_names, user_counts))
@@ -967,8 +967,8 @@ impl RoomListResponse {
 
     fn encode_rooms(
         rooms: &[(String, u32)],
-        encoder: &mut ProtoEncoder,
-    ) -> Result<(), ProtoEncodeError> {
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         let mut room_names = vec![];
         let mut user_counts = vec![];
 
@@ -982,8 +982,8 @@ impl RoomListResponse {
     }
 }
 
-impl ProtoEncode for RoomListResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomListResponse {
+    fn encode(&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)?;
@@ -991,8 +991,8 @@ impl ProtoEncode for RoomListResponse {
     }
 }
 
-impl ProtoDecode for RoomListResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomListResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let rooms = RoomListResponse::decode_rooms(decoder)?;
         let owned_private_rooms = RoomListResponse::decode_rooms(decoder)?;
         let other_private_rooms = RoomListResponse::decode_rooms(decoder)?;
@@ -1030,16 +1030,16 @@ impl ReadFromPacket for RoomMessageResponse {
     }
 }
 
-impl ProtoEncode for RoomMessageResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomMessageResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.user_name)?;
         encoder.encode_string(&self.message)
     }
 }
 
-impl ProtoDecode for RoomMessageResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomMessageResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_name = decoder.decode()?;
         let message = decoder.decode()?;
@@ -1077,15 +1077,15 @@ impl ReadFromPacket for RoomTickersResponse {
     }
 }
 
-impl ProtoEncode for RoomTickersResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomTickersResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode(&self.tickers)
     }
 }
 
-impl ProtoDecode for RoomTickersResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomTickersResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let tickers = decoder.decode()?;
         Ok(RoomTickersResponse { room_name, tickers })
@@ -1135,8 +1135,8 @@ impl ReadFromPacket for RoomUserJoinedResponse {
     }
 }
 
-impl ProtoEncode for RoomUserJoinedResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomUserJoinedResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.user.name)?;
         self.user.status.encode(encoder)?;
@@ -1146,8 +1146,8 @@ impl ProtoEncode for RoomUserJoinedResponse {
     }
 }
 
-impl ProtoDecode for RoomUserJoinedResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomUserJoinedResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_name = decoder.decode()?;
         let status = decoder.decode()?;
@@ -1182,15 +1182,15 @@ impl ReadFromPacket for RoomUserLeftResponse {
     }
 }
 
-impl ProtoEncode for RoomUserLeftResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for RoomUserLeftResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.user_name)
     }
 }
 
-impl ProtoDecode for RoomUserLeftResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for RoomUserLeftResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_name = decoder.decode()?;
         Ok(RoomUserLeftResponse {
@@ -1230,8 +1230,8 @@ impl ReadFromPacket for UserInfoResponse {
     }
 }
 
-impl ProtoEncode for UserInfoResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for UserInfoResponse {
+    fn encode(&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)?;
@@ -1240,8 +1240,8 @@ impl ProtoEncode for UserInfoResponse {
     }
 }
 
-impl ProtoDecode for UserInfoResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for UserInfoResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let average_speed: u32 = decoder.decode()?;
         let num_downloads: u32 = decoder.decode()?;
@@ -1281,16 +1281,16 @@ impl ReadFromPacket for UserStatusResponse {
     }
 }
 
-impl ProtoEncode for UserStatusResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for UserStatusResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)?;
         self.status.encode(encoder)?;
         encoder.encode_bool(self.is_privileged)
     }
 }
 
-impl ProtoDecode for UserStatusResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for UserStatusResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let status = decoder.decode()?;
         let is_privileged = decoder.decode()?;
@@ -1318,14 +1318,14 @@ impl ReadFromPacket for WishlistIntervalResponse {
     }
 }
 
-impl ProtoEncode for WishlistIntervalResponse {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for WishlistIntervalResponse {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.seconds)
     }
 }
 
-impl ProtoDecode for WishlistIntervalResponse {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for WishlistIntervalResponse {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let seconds = decoder.decode()?;
         Ok(WishlistIntervalResponse { seconds })
     }
@@ -1343,7 +1343,7 @@ mod tests {
     use bytes::BytesMut;
 
     use crate::proto::base_codec::tests::roundtrip;
-    use crate::proto::{ProtoDecodeError, ProtoDecoder};
+    use crate::proto::{ValueDecodeError, ValueDecoder};
 
     use super::*;
 
@@ -1351,11 +1351,11 @@ mod tests {
     fn invalid_code() {
         let bytes = BytesMut::from(vec![57, 5, 0, 0]);
 
-        let result = ProtoDecoder::new(&bytes).decode::<ServerResponse>();
+        let result = ValueDecoder::new(&bytes).decode::<ServerResponse>();
 
         assert_eq!(
             result,
-            Err(ProtoDecodeError::InvalidData {
+            Err(ValueDecodeError::InvalidData {
                 value_name: "server response code".to_string(),
                 cause: "unknown value 1337".to_string(),
                 position: 0,

src/proto/user.rs

@@ -1,8 +1,8 @@
 use std::io;
 
 use crate::proto::{
-    MutPacket, Packet, PacketReadError, ProtoDecode, ProtoDecodeError, ProtoDecoder, ProtoEncode,
-    ProtoEncodeError, ProtoEncoder, ReadFromPacket, WriteToPacket,
+    MutPacket, Packet, PacketReadError, ReadFromPacket, ValueDecode, ValueDecodeError,
+    ValueDecoder, ValueEncode, ValueEncodeError, ValueEncoder, WriteToPacket,
 };
 
 const STATUS_OFFLINE: u32 = 1;
@@ -44,8 +44,8 @@ impl WriteToPacket for UserStatus {
     }
 }
 
-impl ProtoEncode for UserStatus {
-    fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> {
+impl ValueEncode for UserStatus {
+    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
         let value = match *self {
             UserStatus::Offline => STATUS_OFFLINE,
             UserStatus::Away => STATUS_AWAY,
@@ -55,15 +55,15 @@ impl ProtoEncode for UserStatus {
     }
 }
 
-impl ProtoDecode for UserStatus {
-    fn decode_from(decoder: &mut ProtoDecoder) -> Result<Self, ProtoDecodeError> {
+impl ValueDecode for UserStatus {
+    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let value: u32 = decoder.decode()?;
         match value {
             STATUS_OFFLINE => Ok(UserStatus::Offline),
             STATUS_AWAY => Ok(UserStatus::Away),
             STATUS_ONLINE => Ok(UserStatus::Online),
-            _ => Err(ProtoDecodeError::InvalidData {
+            _ => Err(ValueDecodeError::InvalidData {
                 value_name: "user status".to_string(),
                 cause: format!("unknown value {}", value),
                 position: position,