| use std::io::Write; | |
| use std::mem::size_of; | |
| use super::Options; | |
| use de::read::BincodeRead; | |
| use error::{ErrorKind, Result}; | |
| pub trait IntEncoding { | |
| /// Gets the size (in bytes) that a value would be serialized to. | |
| fn u16_size(n: u16) -> u64; | |
| /// Gets the size (in bytes) that a value would be serialized to. | |
| fn u32_size(n: u32) -> u64; | |
| /// Gets the size (in bytes) that a value would be serialized to. | |
| fn u64_size(n: u64) -> u64; | |
| /// Gets the size (in bytes) that a value would be serialized to. | |
| fn i16_size(n: i16) -> u64; | |
| /// Gets the size (in bytes) that a value would be serialized to. | |
| fn i32_size(n: i32) -> u64; | |
| /// Gets the size (in bytes) that a value would be serialized to. | |
| fn i64_size(n: i64) -> u64; | |
| #[inline(always)] | |
| fn len_size(len: usize) -> u64 { | |
| Self::u64_size(len as u64) | |
| } | |
| /// Serializes a sequence length. | |
| #[inline(always)] | |
| fn serialize_len<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| len: usize, | |
| ) -> Result<()> { | |
| Self::serialize_u64(ser, len as u64) | |
| } | |
| fn serialize_u16<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| val: u16, | |
| ) -> Result<()>; | |
| fn serialize_u32<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| val: u32, | |
| ) -> Result<()>; | |
| fn serialize_u64<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| val: u64, | |
| ) -> Result<()>; | |
| fn serialize_i16<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| val: i16, | |
| ) -> Result<()>; | |
| fn serialize_i32<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| val: i32, | |
| ) -> Result<()>; | |
| fn serialize_i64<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| val: i64, | |
| ) -> Result<()>; | |
| /// Deserializes a sequence length. | |
| #[inline(always)] | |
| fn deserialize_len<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<usize> { | |
| Self::deserialize_u64(de).and_then(cast_u64_to_usize) | |
| } | |
| fn deserialize_u16<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<u16>; | |
| fn deserialize_u32<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<u32>; | |
| fn deserialize_u64<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<u64>; | |
| fn deserialize_i16<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<i16>; | |
| fn deserialize_i32<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<i32>; | |
| fn deserialize_i64<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<i64>; | |
| serde_if_integer128! { | |
| fn u128_size(v: u128) -> u64; | |
| fn i128_size(v: i128) -> u64; | |
| fn serialize_u128<W: Write, O: Options>( | |
| ser: &mut ::Serializer<W, O>, | |
| val: u128, | |
| ) -> Result<()>; | |
| fn deserialize_u128<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u128>; | |
| fn serialize_i128<W: Write, O: Options>( | |
| ser: &mut ::Serializer<W, O>, | |
| val: i128, | |
| ) -> Result<()>; | |
| fn deserialize_i128<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i128>; | |
| } | |
| } | |
| /// Fixed-size integer encoding. | |
| /// | |
| /// * Fixed size integers are encoded directly | |
| /// * Enum discriminants are encoded as u32 | |
| /// * Lengths and usize are encoded as u64 | |
| #[derive(Copy, Clone)] | |
| pub struct FixintEncoding; | |
| /// Variable-size integer encoding (excepting [ui]8). | |
| /// | |
| /// Encoding an unsigned integer v (of any type excepting u8) works as follows: | |
| /// | |
| /// 1. If `u < 251`, encode it as a single byte with that value. | |
| /// 2. If `251 <= u < 2**16`, encode it as a literal byte 251, followed by a u16 with value `u`. | |
| /// 3. If `2**16 <= u < 2**32`, encode it as a literal byte 252, followed by a u32 with value `u`. | |
| /// 4. If `2**32 <= u < 2**64`, encode it as a literal byte 253, followed by a u64 with value `u`. | |
| /// 5. If `2**64 <= u < 2**128`, encode it as a literal byte 254, followed by a | |
| /// u128 with value `u`. | |
| /// | |
| /// Then, for signed integers, we first convert to unsigned using the zigzag algorithm, | |
| /// and then encode them as we do for unsigned integers generally. The reason we use this | |
| /// algorithm is that it encodes those values which are close to zero in less bytes; the | |
| /// obvious algorithm, where we encode the cast values, gives a very large encoding for all | |
| /// negative values. | |
| /// | |
| /// The zigzag algorithm is defined as follows: | |
| /// | |
| /// ```ignore | |
| /// fn zigzag(v: Signed) -> Unsigned { | |
| /// match v { | |
| /// 0 => 0, | |
| /// v if v < 0 => |v| * 2 - 1 | |
| /// v if v > 0 => v * 2 | |
| /// } | |
| /// } | |
| /// ``` | |
| /// | |
| /// And works such that: | |
| /// | |
| /// ```ignore | |
| /// assert_eq!(zigzag(0), 0); | |
| /// assert_eq!(zigzag(-1), 1); | |
| /// assert_eq!(zigzag(1), 2); | |
| /// assert_eq!(zigzag(-2), 3); | |
| /// assert_eq!(zigzag(2), 4); | |
| /// assert_eq!(zigzag(i64::min_value()), u64::max_value()); | |
| /// ``` | |
| /// | |
| /// Note that u256 and the like are unsupported by this format; if and when they are added to the | |
| /// language, they may be supported via the extension point given by the 255 byte. | |
| #[derive(Copy, Clone)] | |
| pub struct VarintEncoding; | |
| const SINGLE_BYTE_MAX: u8 = 250; | |
| const U16_BYTE: u8 = 251; | |
| const U32_BYTE: u8 = 252; | |
| const U64_BYTE: u8 = 253; | |
| const U128_BYTE: u8 = 254; | |
| const DESERIALIZE_EXTENSION_POINT_ERR: &str = r#" | |
| Byte 255 is treated as an extension point; it should not be encoding anything. | |
| Do you have a mismatched bincode version or configuration? | |
| "#; | |
| impl VarintEncoding { | |
| fn varint_size(n: u64) -> u64 { | |
| if n <= SINGLE_BYTE_MAX as u64 { | |
| 1 | |
| } else if n <= u16::max_value() as u64 { | |
| (1 + size_of::<u16>()) as u64 | |
| } else if n <= u32::max_value() as u64 { | |
| (1 + size_of::<u32>()) as u64 | |
| } else { | |
| (1 + size_of::<u64>()) as u64 | |
| } | |
| } | |
| #[inline(always)] | |
| fn zigzag_encode(n: i64) -> u64 { | |
| if n < 0 { | |
| // let's avoid the edge case of i64::min_value() | |
| // !n is equal to `-n - 1`, so this is: | |
| // !n * 2 + 1 = 2(-n - 1) + 1 = -2n - 2 + 1 = -2n - 1 | |
| !(n as u64) * 2 + 1 | |
| } else { | |
| (n as u64) * 2 | |
| } | |
| } | |
| #[inline(always)] | |
| fn zigzag_decode(n: u64) -> i64 { | |
| if n % 2 == 0 { | |
| // positive number | |
| (n / 2) as i64 | |
| } else { | |
| // negative number | |
| // !m * 2 + 1 = n | |
| // !m * 2 = n - 1 | |
| // !m = (n - 1) / 2 | |
| // m = !((n - 1) / 2) | |
| // since we have n is odd, we have floor(n / 2) = floor((n - 1) / 2) | |
| !(n / 2) as i64 | |
| } | |
| } | |
| fn serialize_varint<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| n: u64, | |
| ) -> Result<()> { | |
| if n <= SINGLE_BYTE_MAX as u64 { | |
| ser.serialize_byte(n as u8) | |
| } else if n <= u16::max_value() as u64 { | |
| ser.serialize_byte(U16_BYTE)?; | |
| ser.serialize_literal_u16(n as u16) | |
| } else if n <= u32::max_value() as u64 { | |
| ser.serialize_byte(U32_BYTE)?; | |
| ser.serialize_literal_u32(n as u32) | |
| } else { | |
| ser.serialize_byte(U64_BYTE)?; | |
| ser.serialize_literal_u64(n as u64) | |
| } | |
| } | |
| fn deserialize_varint<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<u64> { | |
| #[allow(ellipsis_inclusive_range_patterns)] | |
| match de.deserialize_byte()? { | |
| byte @ 0...SINGLE_BYTE_MAX => Ok(byte as u64), | |
| U16_BYTE => Ok(de.deserialize_literal_u16()? as u64), | |
| U32_BYTE => Ok(de.deserialize_literal_u32()? as u64), | |
| U64_BYTE => de.deserialize_literal_u64(), | |
| U128_BYTE => Err(Box::new(ErrorKind::Custom( | |
| "Invalid value (u128 range): you may have a version or configuration disagreement?" | |
| .to_string(), | |
| ))), | |
| _ => Err(Box::new(ErrorKind::Custom( | |
| DESERIALIZE_EXTENSION_POINT_ERR.to_string(), | |
| ))), | |
| } | |
| } | |
| serde_if_integer128! { | |
| // see zigzag_encode and zigzag_decode for implementation comments | |
| #[inline(always)] | |
| fn zigzag128_encode(n: i128) -> u128 { | |
| if n < 0 { | |
| !(n as u128) * 2 + 1 | |
| } else { | |
| (n as u128) * 2 | |
| } | |
| } | |
| #[inline(always)] | |
| fn zigzag128_decode(n: u128) -> i128 { | |
| if n % 2 == 0 { | |
| (n / 2) as i128 | |
| } else { | |
| !(n / 2) as i128 | |
| } | |
| } | |
| fn varint128_size(n: u128) -> u64 { | |
| if n <= SINGLE_BYTE_MAX as u128 { | |
| 1 | |
| } else if n <= u16::max_value() as u128 { | |
| (1 + size_of::<u16>()) as u64 | |
| } else if n <= u32::max_value() as u128 { | |
| (1 + size_of::<u32>()) as u64 | |
| } else if n <= u64::max_value() as u128 { | |
| (1 + size_of::<u64>()) as u64 | |
| } else { | |
| (1 + size_of::<u128>()) as u64 | |
| } | |
| } | |
| fn serialize_varint128<W: Write, O: Options>( | |
| ser: &mut ::ser::Serializer<W, O>, | |
| n: u128, | |
| ) -> Result<()> { | |
| if n <= SINGLE_BYTE_MAX as u128 { | |
| ser.serialize_byte(n as u8) | |
| } else if n <= u16::max_value() as u128 { | |
| ser.serialize_byte(U16_BYTE)?; | |
| ser.serialize_literal_u16(n as u16) | |
| } else if n <= u32::max_value() as u128 { | |
| ser.serialize_byte(U32_BYTE)?; | |
| ser.serialize_literal_u32(n as u32) | |
| } else if n <= u64::max_value() as u128 { | |
| ser.serialize_byte(U64_BYTE)?; | |
| ser.serialize_literal_u64(n as u64) | |
| } else { | |
| ser.serialize_byte(U128_BYTE)?; | |
| ser.serialize_literal_u128(n) | |
| } | |
| } | |
| fn deserialize_varint128<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::de::Deserializer<R, O>, | |
| ) -> Result<u128> { | |
| #[allow(ellipsis_inclusive_range_patterns)] | |
| match de.deserialize_byte()? { | |
| byte @ 0...SINGLE_BYTE_MAX => Ok(byte as u128), | |
| U16_BYTE => Ok(de.deserialize_literal_u16()? as u128), | |
| U32_BYTE => Ok(de.deserialize_literal_u32()? as u128), | |
| U64_BYTE => Ok(de.deserialize_literal_u64()? as u128), | |
| U128_BYTE => de.deserialize_literal_u128(), | |
| _ => Err(Box::new(ErrorKind::Custom(DESERIALIZE_EXTENSION_POINT_ERR.to_string()))), | |
| } | |
| } | |
| } | |
| } | |
| impl IntEncoding for FixintEncoding { | |
| #[inline(always)] | |
| fn u16_size(_: u16) -> u64 { | |
| size_of::<u16>() as u64 | |
| } | |
| #[inline(always)] | |
| fn u32_size(_: u32) -> u64 { | |
| size_of::<u32>() as u64 | |
| } | |
| #[inline(always)] | |
| fn u64_size(_: u64) -> u64 { | |
| size_of::<u64>() as u64 | |
| } | |
| #[inline(always)] | |
| fn i16_size(_: i16) -> u64 { | |
| size_of::<i16>() as u64 | |
| } | |
| #[inline(always)] | |
| fn i32_size(_: i32) -> u64 { | |
| size_of::<i32>() as u64 | |
| } | |
| #[inline(always)] | |
| fn i64_size(_: i64) -> u64 { | |
| size_of::<i64>() as u64 | |
| } | |
| #[inline(always)] | |
| fn serialize_u16<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: u16) -> Result<()> { | |
| ser.serialize_literal_u16(val) | |
| } | |
| #[inline(always)] | |
| fn serialize_u32<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: u32) -> Result<()> { | |
| ser.serialize_literal_u32(val) | |
| } | |
| #[inline(always)] | |
| fn serialize_u64<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: u64) -> Result<()> { | |
| ser.serialize_literal_u64(val) | |
| } | |
| #[inline(always)] | |
| fn serialize_i16<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: i16) -> Result<()> { | |
| ser.serialize_literal_u16(val as u16) | |
| } | |
| #[inline(always)] | |
| fn serialize_i32<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: i32) -> Result<()> { | |
| ser.serialize_literal_u32(val as u32) | |
| } | |
| #[inline(always)] | |
| fn serialize_i64<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: i64) -> Result<()> { | |
| ser.serialize_literal_u64(val as u64) | |
| } | |
| #[inline(always)] | |
| fn deserialize_u16<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u16> { | |
| de.deserialize_literal_u16() | |
| } | |
| #[inline(always)] | |
| fn deserialize_u32<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u32> { | |
| de.deserialize_literal_u32() | |
| } | |
| #[inline(always)] | |
| fn deserialize_u64<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u64> { | |
| de.deserialize_literal_u64() | |
| } | |
| #[inline(always)] | |
| fn deserialize_i16<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i16> { | |
| Ok(de.deserialize_literal_u16()? as i16) | |
| } | |
| #[inline(always)] | |
| fn deserialize_i32<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i32> { | |
| Ok(de.deserialize_literal_u32()? as i32) | |
| } | |
| #[inline(always)] | |
| fn deserialize_i64<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i64> { | |
| Ok(de.deserialize_literal_u64()? as i64) | |
| } | |
| serde_if_integer128! { | |
| #[inline(always)] | |
| fn u128_size(_: u128) -> u64{ | |
| size_of::<u128>() as u64 | |
| } | |
| #[inline(always)] | |
| fn i128_size(_: i128) -> u64{ | |
| size_of::<i128>() as u64 | |
| } | |
| #[inline(always)] | |
| fn serialize_u128<W: Write, O: Options>( | |
| ser: &mut ::Serializer<W, O>, | |
| val: u128, | |
| ) -> Result<()> { | |
| ser.serialize_literal_u128(val) | |
| } | |
| #[inline(always)] | |
| fn serialize_i128<W: Write, O: Options>( | |
| ser: &mut ::Serializer<W, O>, | |
| val: i128, | |
| ) -> Result<()> { | |
| ser.serialize_literal_u128(val as u128) | |
| } | |
| #[inline(always)] | |
| fn deserialize_u128<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u128> { | |
| de.deserialize_literal_u128() | |
| } | |
| #[inline(always)] | |
| fn deserialize_i128<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i128> { | |
| Ok(de.deserialize_literal_u128()? as i128) | |
| } | |
| } | |
| } | |
| impl IntEncoding for VarintEncoding { | |
| #[inline(always)] | |
| fn u16_size(n: u16) -> u64 { | |
| Self::varint_size(n as u64) | |
| } | |
| #[inline(always)] | |
| fn u32_size(n: u32) -> u64 { | |
| Self::varint_size(n as u64) | |
| } | |
| #[inline(always)] | |
| fn u64_size(n: u64) -> u64 { | |
| Self::varint_size(n) | |
| } | |
| #[inline(always)] | |
| fn i16_size(n: i16) -> u64 { | |
| Self::varint_size(Self::zigzag_encode(n as i64)) | |
| } | |
| #[inline(always)] | |
| fn i32_size(n: i32) -> u64 { | |
| Self::varint_size(Self::zigzag_encode(n as i64)) | |
| } | |
| #[inline(always)] | |
| fn i64_size(n: i64) -> u64 { | |
| Self::varint_size(Self::zigzag_encode(n)) | |
| } | |
| #[inline(always)] | |
| fn serialize_u16<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: u16) -> Result<()> { | |
| Self::serialize_varint(ser, val as u64) | |
| } | |
| #[inline(always)] | |
| fn serialize_u32<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: u32) -> Result<()> { | |
| Self::serialize_varint(ser, val as u64) | |
| } | |
| #[inline(always)] | |
| fn serialize_u64<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: u64) -> Result<()> { | |
| Self::serialize_varint(ser, val) | |
| } | |
| #[inline(always)] | |
| fn serialize_i16<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: i16) -> Result<()> { | |
| Self::serialize_varint(ser, Self::zigzag_encode(val as i64)) | |
| } | |
| #[inline(always)] | |
| fn serialize_i32<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: i32) -> Result<()> { | |
| Self::serialize_varint(ser, Self::zigzag_encode(val as i64)) | |
| } | |
| #[inline(always)] | |
| fn serialize_i64<W: Write, O: Options>(ser: &mut ::Serializer<W, O>, val: i64) -> Result<()> { | |
| Self::serialize_varint(ser, Self::zigzag_encode(val)) | |
| } | |
| #[inline(always)] | |
| fn deserialize_u16<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u16> { | |
| Self::deserialize_varint(de).and_then(cast_u64_to_u16) | |
| } | |
| #[inline(always)] | |
| fn deserialize_u32<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u32> { | |
| Self::deserialize_varint(de).and_then(cast_u64_to_u32) | |
| } | |
| #[inline(always)] | |
| fn deserialize_u64<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u64> { | |
| Self::deserialize_varint(de) | |
| } | |
| #[inline(always)] | |
| fn deserialize_i16<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i16> { | |
| Self::deserialize_varint(de) | |
| .map(Self::zigzag_decode) | |
| .and_then(cast_i64_to_i16) | |
| } | |
| #[inline(always)] | |
| fn deserialize_i32<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i32> { | |
| Self::deserialize_varint(de) | |
| .map(Self::zigzag_decode) | |
| .and_then(cast_i64_to_i32) | |
| } | |
| #[inline(always)] | |
| fn deserialize_i64<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i64> { | |
| Self::deserialize_varint(de).map(Self::zigzag_decode) | |
| } | |
| serde_if_integer128! { | |
| #[inline(always)] | |
| fn u128_size(n: u128) -> u64 { | |
| Self::varint128_size(n) | |
| } | |
| #[inline(always)] | |
| fn i128_size(n: i128) -> u64 { | |
| Self::varint128_size(Self::zigzag128_encode(n)) | |
| } | |
| #[inline(always)] | |
| fn serialize_u128<W: Write, O: Options>( | |
| ser: &mut ::Serializer<W, O>, | |
| val: u128, | |
| ) -> Result<()> { | |
| Self::serialize_varint128(ser, val) | |
| } | |
| #[inline(always)] | |
| fn serialize_i128<W: Write, O: Options>( | |
| ser: &mut ::Serializer<W, O>, | |
| val: i128, | |
| ) -> Result<()> { | |
| Self::serialize_varint128(ser, Self::zigzag128_encode(val)) | |
| } | |
| #[inline(always)] | |
| fn deserialize_u128<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<u128> { | |
| Self::deserialize_varint128(de) | |
| } | |
| #[inline(always)] | |
| fn deserialize_i128<'de, R: BincodeRead<'de>, O: Options>( | |
| de: &mut ::Deserializer<R, O>, | |
| ) -> Result<i128> { | |
| Self::deserialize_varint128(de).map(Self::zigzag128_decode) | |
| } | |
| } | |
| } | |
| fn cast_u64_to_usize(n: u64) -> Result<usize> { | |
| if n <= usize::max_value() as u64 { | |
| Ok(n as usize) | |
| } else { | |
| Err(Box::new(ErrorKind::Custom(format!( | |
| "Invalid size {}: sizes must fit in a usize (0 to {})", | |
| n, | |
| usize::max_value() | |
| )))) | |
| } | |
| } | |
| fn cast_u64_to_u32(n: u64) -> Result<u32> { | |
| if n <= u32::max_value() as u64 { | |
| Ok(n as u32) | |
| } else { | |
| Err(Box::new(ErrorKind::Custom(format!( | |
| "Invalid u32 {}: you may have a version disagreement?", | |
| n, | |
| )))) | |
| } | |
| } | |
| fn cast_u64_to_u16(n: u64) -> Result<u16> { | |
| if n <= u16::max_value() as u64 { | |
| Ok(n as u16) | |
| } else { | |
| Err(Box::new(ErrorKind::Custom(format!( | |
| "Invalid u16 {}: you may have a version disagreement?", | |
| n, | |
| )))) | |
| } | |
| } | |
| fn cast_i64_to_i32(n: i64) -> Result<i32> { | |
| if n <= i32::max_value() as i64 && n >= i32::min_value() as i64 { | |
| Ok(n as i32) | |
| } else { | |
| Err(Box::new(ErrorKind::Custom(format!( | |
| "Invalid i32 {}: you may have a version disagreement?", | |
| n, | |
| )))) | |
| } | |
| } | |
| fn cast_i64_to_i16(n: i64) -> Result<i16> { | |
| if n <= i16::max_value() as i64 && n >= i16::min_value() as i64 { | |
| Ok(n as i16) | |
| } else { | |
| Err(Box::new(ErrorKind::Custom(format!( | |
| "Invalid i16 {}: you may have a version disagreement?", | |
| n, | |
| )))) | |
| } | |
| } | |
| #[cfg(test)] | |
| mod test { | |
| use super::VarintEncoding; | |
| #[test] | |
| fn test_zigzag_encode() { | |
| let zigzag = VarintEncoding::zigzag_encode; | |
| assert_eq!(zigzag(0), 0); | |
| for x in 1..512 { | |
| assert_eq!(zigzag(x), (x as u64) * 2); | |
| assert_eq!(zigzag(-x), (x as u64) * 2 - 1); | |
| } | |
| } | |
| #[test] | |
| fn test_zigzag_decode() { | |
| // zigzag' | |
| let zigzagp = VarintEncoding::zigzag_decode; | |
| for x in (0..512).map(|x| x * 2) { | |
| assert_eq!(zigzagp(x), x as i64 / 2); | |
| assert_eq!(zigzagp(x + 1), -(x as i64) / 2 - 1); | |
| } | |
| } | |
| #[test] | |
| fn test_zigzag_edge_cases() { | |
| let (zigzag, zigzagp) = (VarintEncoding::zigzag_encode, VarintEncoding::zigzag_decode); | |
| assert_eq!(zigzag(i64::max_value()), u64::max_value() - 1); | |
| assert_eq!(zigzag(i64::min_value()), u64::max_value()); | |
| assert_eq!(zigzagp(u64::max_value() - 1), i64::max_value()); | |
| assert_eq!(zigzagp(u64::max_value()), i64::min_value()); | |
| } | |
| } |