From b18fe56f05aef40c9aeb4dd4f47e1b3e42e6b071 Mon Sep 17 00:00:00 2001 From: Titouan Rigoudy Date: Sun, 5 Jul 2020 13:57:07 +0000 Subject: [PATCH] Rename Proto{En,De}code to Value{En,De}code. --- src/proto/base_codec.rs | 198 +++++++++++++++++------------------ src/proto/codec.rs | 20 ++-- src/proto/mod.rs | 4 +- src/proto/peer/message.rs | 28 ++--- src/proto/server/request.rs | 98 ++++++++--------- src/proto/server/response.rs | 170 +++++++++++++++--------------- src/proto/user.rs | 14 +-- 7 files changed, 266 insertions(+), 266 deletions(-) diff --git a/src/proto/base_codec.rs b/src/proto/base_codec.rs index 7706eba..4b1adf7 100644 --- a/src/proto/base_codec.rs +++ b/src/proto/base_codec.rs @@ -40,7 +40,7 @@ pub trait Encode { // 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 for io::Error { - fn from(error: ProtoDecodeError) -> Self { +impl From 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 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; + fn decode_from(decoder: &mut ValueDecoder) -> Result; } -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 { + fn decode_u32(&mut self) -> Result { 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 { + fn decode_u16(&mut self) -> Result { 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 { + fn decode_bool(&mut self) -> Result { 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 { + fn decode_string(&mut self) -> Result { 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(&mut self) -> Result { + pub fn decode(&mut self) -> Result { T::decode_from(self) } } -impl ProtoDecode for u32 { - fn decode_from(decoder: &mut ProtoDecoder) -> Result { +impl ValueDecode for u32 { + fn decode_from(decoder: &mut ValueDecoder) -> Result { decoder.decode_u32() } } -impl ProtoDecode for u16 { - fn decode_from(decoder: &mut ProtoDecoder) -> Result { +impl ValueDecode for u16 { + fn decode_from(decoder: &mut ValueDecoder) -> Result { decoder.decode_u16() } } -impl ProtoDecode for bool { - fn decode_from(decoder: &mut ProtoDecoder) -> Result { +impl ValueDecode for bool { + fn decode_from(decoder: &mut ValueDecoder) -> Result { decoder.decode_bool() } } -impl ProtoDecode for net::Ipv4Addr { - fn decode_from(decoder: &mut ProtoDecoder) -> Result { +impl ValueDecode for net::Ipv4Addr { + fn decode_from(decoder: &mut ValueDecoder) -> Result { let ip = decoder.decode_u32()?; Ok(net::Ipv4Addr::from(ip)) } } -impl ProtoDecode for String { - fn decode_from(decoder: &mut ProtoDecoder) -> Result { +impl ValueDecode for String { + fn decode_from(decoder: &mut ValueDecoder) -> Result { decoder.decode_string() } } -impl ProtoDecode for (T, U) { - fn decode_from(decoder: &mut ProtoDecoder) -> Result { +impl ValueDecode for (T, U) { + fn decode_from(decoder: &mut ValueDecoder) -> Result { let first = decoder.decode()?; let second = decoder.decode()?; Ok((first, second)) } } -impl ProtoDecode for Vec { - fn decode_from(decoder: &mut ProtoDecoder) -> Result { +impl ValueDecode for Vec { + fn decode_from(decoder: &mut ValueDecoder) -> Result { let len = decoder.decode_u32()? as usize; let mut vec = Vec::with_capacity(len); for _ in 0..len { @@ -299,7 +299,7 @@ impl ProtoDecode for Vec { } #[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 for io::Error { - fn from(error: ProtoEncodeError) -> Self { +impl From 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, } /// 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) -> 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(&mut self, val: &T) -> Result<(), ProtoEncodeError> { + pub fn encode(&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 ProtoEncode for (T, U) { - fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> { +impl ValueEncode for (T, U) { + fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> { self.0.encode(encoder)?; self.1.encode(encoder) } } -impl ProtoEncode for [T] { - fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> { +impl 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 ProtoEncode for [T] { } } -impl ProtoEncode for Vec { - fn encode(&self, encoder: &mut ProtoEncoder) -> Result<(), ProtoEncodeError> { +impl ValueEncode for Vec { + 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(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::().unwrap(); + ValueEncoder::new(&mut bytes).encode(&input).unwrap(); + let output = ValueDecoder::new(&bytes).decode::().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::().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::(); 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::().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::().unwrap(); @@ -606,11 +606,11 @@ pub mod tests { fn decode_bool_invalid() { let buffer = vec![42]; - let result = ProtoDecoder::new(&buffer).decode::(); + let result = ValueDecoder::new(&buffer).decode::(); 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::(); + let result = ValueDecoder::new(&buffer).decode::(); 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::().unwrap(); @@ -667,7 +667,7 @@ pub mod tests { } else { assert_eq!( decoder.decode::(), - 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::(); 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::().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::().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::>().unwrap(); diff --git a/src/proto/codec.rs b/src/proto/codec.rs index 91022a3..9a9f88b 100644 --- a/src/proto/codec.rs +++ b/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 { phantom: marker::PhantomData, } @@ -34,7 +34,7 @@ impl LengthPrefixedEncoder { } } -impl tokio_codec::Encoder for LengthPrefixedEncoder { +impl tokio_codec::Encoder for LengthPrefixedEncoder { type Item = T; type Error = io::Error; @@ -43,11 +43,11 @@ impl tokio_codec::Encoder for LengthPrefixedEncoder { // 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 tokio_codec::Encoder for LengthPrefixedEncoder { } } -/// Implements tokio's Decoder trait for types that implement ProtoDecode. +/// Implements tokio's Decoder trait for types that implement ValueDecode. pub struct LengthPrefixedDecoder { // 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 LengthPrefixedDecoder { } let prefix = src.split_to(U32_BYTE_LEN); - let length = ProtoDecoder::new(&prefix).decode::()?; + let length = ValueDecoder::new(&prefix).decode::()?; self.length = Some(length as usize); Ok(()) } } -impl tokio_codec::Decoder for LengthPrefixedDecoder { +impl tokio_codec::Decoder for LengthPrefixedDecoder { type Item = T; type Error = io::Error; @@ -124,7 +124,7 @@ impl tokio_codec::Decoder for LengthPrefixedDecoder { 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}; diff --git a/src/proto/mod.rs b/src/proto/mod.rs index c68a585..208a556 100644 --- a/src/proto/mod.rs +++ b/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::*; diff --git a/src/proto/peer/message.rs b/src/proto/peer/message.rs index a797c0f..38a0be4 100644 --- a/src/proto/peer/message.rs +++ b/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 { +impl ValueDecode for Message { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for PeerInit { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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::(); + let result = ValueDecoder::new(&bytes).decode::(); assert_eq!( result, - Err(ProtoDecodeError::InvalidData { + Err(ValueDecodeError::InvalidData { value_name: "peer message code".to_string(), cause: "unknown value 1337".to_string(), position: 0, diff --git a/src/proto/server/request.rs b/src/proto/server/request.rs index 6d66f93..0e613b2 100644 --- a/src/proto/server/request.rs +++ b/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 { +impl ValueDecode for ServerRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for CannotConnectRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for ConnectToPeerRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for FileSearchRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for LoginRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for PeerAddressRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomJoinRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomLeaveRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomMessageRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for SetListenPortRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for UserStatusRequest { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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::(); + let result = ValueDecoder::new(&bytes).decode::(); assert_eq!( result, - Err(ProtoDecodeError::InvalidData { + Err(ValueDecodeError::InvalidData { value_name: "server request code".to_string(), cause: "unknown value 1337".to_string(), position: 0, diff --git a/src/proto/server/response.rs b/src/proto/server/response.rs index e1a2988..ec2ec23 100644 --- a/src/proto/server/response.rs +++ b/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 { +impl ValueDecode for ServerResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for ConnectToPeerResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for FileSearchResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for LoginResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for ParentMinSpeedResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for ParentSpeedRatioResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for PeerAddressResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for PrivilegedUsersResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for UserInfo { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomJoinResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomLeaveResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { let room_name = decoder.decode()?; Ok(RoomLeaveResponse { room_name }) } @@ -959,7 +959,7 @@ impl RoomListResponse { rooms } - fn decode_rooms(decoder: &mut ProtoDecoder) -> Result, ProtoDecodeError> { + fn decode_rooms(decoder: &mut ValueDecoder) -> Result, 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 { +impl ValueDecode for RoomListResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomMessageResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomTickersResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomUserJoinedResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for RoomUserLeftResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for UserInfoResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for UserStatusResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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 { +impl ValueDecode for WishlistIntervalResponse { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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::(); + let result = ValueDecoder::new(&bytes).decode::(); assert_eq!( result, - Err(ProtoDecodeError::InvalidData { + Err(ValueDecodeError::InvalidData { value_name: "server response code".to_string(), cause: "unknown value 1337".to_string(), position: 0, diff --git a/src/proto/user.rs b/src/proto/user.rs index fcd2f20..182de23 100644 --- a/src/proto/user.rs +++ b/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 { +impl ValueDecode for UserStatus { + fn decode_from(decoder: &mut ValueDecoder) -> Result { 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,