berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Switched Decode and BorrowDecode to take &mut D (#470) 

* Switched Decode and BorrowDecode to take &mut D, fixes #467

* I didn't forget to run cargo fmt, you did
This commit is contained in:
Trangar 2022-01-11 20:23:31 +01:00 committed by GitHub
parent 4450fd40a4
commit 4149c0f29f
13 changed files with 173 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
derive/src/derive_enum.rs
View File

@ -201,7 +201,7 @@ impl DeriveEnum {
})
.generate_fn("decode")
.with_generic("D", ["bincode::de::Decoder"])
.with_arg("mut decoder", "D")
.with_arg("decoder", "&mut D")
.with_return_type("core::result::Result<Self, bincode::error::DecodeError>")
.body(|fn_builder| {
if self.variants.is_empty() {
@ -209,7 +209,7 @@ impl DeriveEnum {
} else {
fn_builder
.push_parsed(
"let variant_index = <u32 as bincode::Decode>::decode(&mut decoder)?;",
"let variant_index = <u32 as bincode::Decode>::decode(decoder)?;",
)?;
fn_builder.push_parsed("match variant_index")?;
fn_builder.group(Delimiter::Brace, |variant_case| {
@ -242,10 +242,10 @@ impl DeriveEnum {
variant_body.punct(':');
if field.attributes().has_attribute(FieldAttribute::WithSerde)? {
variant_body
.push_parsed("<bincode::serde::Compat<_> as bincode::Decode>::decode(&mut decoder)?.0,")?;
.push_parsed("<bincode::serde::Compat<_> as bincode::Decode>::decode(decoder)?.0,")?;
} else {
variant_body
.push_parsed("bincode::Decode::decode(&mut decoder)?,")?;
.push_parsed("bincode::Decode::decode(decoder)?,")?;
}
}
Ok(())
@ -277,14 +277,14 @@ impl DeriveEnum {
})
.generate_fn("borrow_decode")
.with_generic("D", ["bincode::de::BorrowDecoder<'__de>"])
.with_arg("mut decoder", "D")
.with_arg("decoder", "&mut D")
.with_return_type("core::result::Result<Self, bincode::error::DecodeError>")
.body(|fn_builder| {
if self.variants.is_empty() {
fn_builder.push_parsed("core::result::Result::Err(bincode::error::DecodeError::EmptyEnum { type_name: core::any::type_name::<Self>() })")?;
} else {
fn_builder
.push_parsed("let variant_index = <u32 as bincode::Decode>::decode(&mut decoder)?;")?;
.push_parsed("let variant_index = <u32 as bincode::Decode>::decode(decoder)?;")?;
fn_builder.push_parsed("match variant_index")?;
fn_builder.group(Delimiter::Brace, |variant_case| {
for (mut variant_index, variant) in self.iter_fields() {
@ -316,9 +316,9 @@ impl DeriveEnum {
variant_body.punct(':');
if field.attributes().has_attribute(FieldAttribute::WithSerde)? {
variant_body
.push_parsed("<bincode::serde::BorrowCompat<_> as bincode::BorrowDecode>::borrow_decode(&mut decoder)?.0,")?;
.push_parsed("<bincode::serde::BorrowCompat<_> as bincode::BorrowDecode>::borrow_decode(decoder)?.0,")?;
} else {
variant_body.push_parsed("bincode::de::BorrowDecode::borrow_decode(&mut decoder)?,")?;
variant_body.push_parsed("bincode::de::BorrowDecode::borrow_decode(decoder)?,")?;
}
}
Ok(())

16
derive/src/derive_struct.rs
View File

@ -58,7 +58,7 @@ impl DeriveStruct {
})
.generate_fn("decode")
.with_generic("D", ["bincode::de::Decoder"])
.with_arg("mut decoder", "D")
.with_arg("decoder", "&mut D")
.with_return_type("core::result::Result<Self, bincode::error::DecodeError>")
.body(|fn_body| {
// Ok(Self {
@ -68,21 +68,21 @@ impl DeriveStruct {
ok_group.group(Delimiter::Brace, |struct_body| {
// Fields
// {
// a: bincode::Decode::decode(&mut decoder)?,
// b: bincode::Decode::decode(&mut decoder)?,
// a: bincode::Decode::decode(decoder)?,
// b: bincode::Decode::decode(decoder)?,
// ...
// }
for field in fields.names() {
if field.attributes().has_attribute(FieldAttribute::WithSerde)? {
struct_body
.push_parsed(format!(
"{}: (<bincode::serde::Compat<_> as bincode::Decode>::decode(&mut decoder)?).0,",
"{}: (<bincode::serde::Compat<_> as bincode::Decode>::decode(decoder)?).0,",
field
))?;
} else {
struct_body
.push_parsed(format!(
"{}: bincode::Decode::decode(&mut decoder)?,",
"{}: bincode::Decode::decode(decoder)?,",
field
))?;
}
@ -109,7 +109,7 @@ impl DeriveStruct {
})
.generate_fn("borrow_decode")
.with_generic("D", ["bincode::de::BorrowDecoder<'__de>"])
.with_arg("mut decoder", "D")
.with_arg("decoder", "&mut D")
.with_return_type("core::result::Result<Self, bincode::error::DecodeError>")
.body(|fn_body| {
// Ok(Self {
@ -121,13 +121,13 @@ impl DeriveStruct {
if field.attributes().has_attribute(FieldAttribute::WithSerde)? {
struct_body
.push_parsed(format!(
"{}: (<bincode::serde::BorrowCompat<_> as bincode::de::BorrowDecode>::borrow_decode(&mut decoder)?).0,",
"{}: (<bincode::serde::BorrowCompat<_> as bincode::de::BorrowDecode>::borrow_decode(decoder)?).0,",
field
))?;
} else {
struct_body
.push_parsed(format!(
"{}: bincode::de::BorrowDecode::borrow_decode(&mut decoder)?,",
"{}: bincode::de::BorrowDecode::borrow_decode(decoder)?,",
field
))?;
}

16
src/de/impl_tuples.rs
View File

@ -5,7 +5,7 @@ impl<A> Decode for (A,)
where
A: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((A::decode(&mut decoder)?,))
}
}
@ -15,7 +15,7 @@ where
A: Decode,
B: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((A::decode(&mut decoder)?, B::decode(&mut decoder)?))
}
}
@ -26,7 +26,7 @@ where
B: Decode,
C: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((
A::decode(&mut decoder)?,
B::decode(&mut decoder)?,
@ -42,7 +42,7 @@ where
C: Decode,
D: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((
A::decode(&mut decoder)?,
B::decode(&mut decoder)?,
@ -60,7 +60,7 @@ where
D: Decode,
E: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((
A::decode(&mut decoder)?,
B::decode(&mut decoder)?,
@ -80,7 +80,7 @@ where
E: Decode,
F: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((
A::decode(&mut decoder)?,
B::decode(&mut decoder)?,
@ -102,7 +102,7 @@ where
F: Decode,
G: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((
A::decode(&mut decoder)?,
B::decode(&mut decoder)?,
@ -126,7 +126,7 @@ where
G: Decode,
H: Decode,
{
fn decode<_D: Decoder>(mut decoder: _D) -> Result<Self, DecodeError> {
fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result<Self, DecodeError> {
Ok((
A::decode(&mut decoder)?,
B::decode(&mut decoder)?,

114
src/de/impls.rs
View File

@ -21,7 +21,7 @@ use core::{
};
impl Decode for bool {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match u8::decode(decoder)? {
0 => Ok(false),
1 => Ok(true),
@ -32,7 +32,7 @@ impl Decode for bool {
impl Decode for u8 {
#[inline]
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(1)?;
if let Some(buf) = decoder.reader().peek_read(1) {
let byte = buf[0];
@ -47,7 +47,7 @@ impl Decode for u8 {
}
impl Decode for NonZeroU8 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroU8::new(u8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U8,
})
@ -55,7 +55,7 @@ impl Decode for NonZeroU8 {
}
impl Decode for u16 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(2)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -74,7 +74,7 @@ impl Decode for u16 {
}
impl Decode for NonZeroU16 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroU16::new(u16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U16,
})
@ -82,7 +82,7 @@ impl Decode for NonZeroU16 {
}
impl Decode for u32 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(4)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -101,7 +101,7 @@ impl Decode for u32 {
}
impl Decode for NonZeroU32 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroU32::new(u32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U32,
})
@ -109,7 +109,7 @@ impl Decode for NonZeroU32 {
}
impl Decode for u64 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -128,7 +128,7 @@ impl Decode for u64 {
}
impl Decode for NonZeroU64 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroU64::new(u64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U64,
})
@ -136,7 +136,7 @@ impl Decode for NonZeroU64 {
}
impl Decode for u128 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(16)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -155,7 +155,7 @@ impl Decode for u128 {
}
impl Decode for NonZeroU128 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroU128::new(u128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U128,
})
@ -163,7 +163,7 @@ impl Decode for NonZeroU128 {
}
impl Decode for usize {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -182,7 +182,7 @@ impl Decode for usize {
}
impl Decode for NonZeroUsize {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroUsize::new(usize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::Usize,
})
@ -190,7 +190,7 @@ impl Decode for NonZeroUsize {
}
impl Decode for i8 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(1)?;
let mut bytes = [0u8; 1];
decoder.reader().read(&mut bytes)?;
@ -199,7 +199,7 @@ impl Decode for i8 {
}
impl Decode for NonZeroI8 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroI8::new(i8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I8,
})
@ -207,7 +207,7 @@ impl Decode for NonZeroI8 {
}
impl Decode for i16 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(2)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -226,7 +226,7 @@ impl Decode for i16 {
}
impl Decode for NonZeroI16 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroI16::new(i16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I16,
})
@ -234,7 +234,7 @@ impl Decode for NonZeroI16 {
}
impl Decode for i32 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(4)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -253,7 +253,7 @@ impl Decode for i32 {
}
impl Decode for NonZeroI32 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroI32::new(i32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I32,
})
@ -261,7 +261,7 @@ impl Decode for NonZeroI32 {
}
impl Decode for i64 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -280,7 +280,7 @@ impl Decode for i64 {
}
impl Decode for NonZeroI64 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroI64::new(i64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I64,
})
@ -288,7 +288,7 @@ impl Decode for NonZeroI64 {
}
impl Decode for i128 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(16)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -307,7 +307,7 @@ impl Decode for i128 {
}
impl Decode for NonZeroI128 {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroI128::new(i128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I128,
})
@ -315,7 +315,7 @@ impl Decode for NonZeroI128 {
}
impl Decode for isize {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING {
IntEncoding::Variable => {
@ -334,7 +334,7 @@ impl Decode for isize {
}
impl Decode for NonZeroIsize {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
NonZeroIsize::new(isize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::Isize,
})
@ -342,7 +342,7 @@ impl Decode for NonZeroIsize {
}
impl Decode for f32 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(4)?;
let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?;
@ -354,7 +354,7 @@ impl Decode for f32 {
}
impl Decode for f64 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
decoder.claim_bytes_read(8)?;
let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?;
@ -366,7 +366,7 @@ impl Decode for f64 {
}
impl Decode for char {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let mut array = [0u8; 4];
// Look at the first byte to see how many bytes must be read
@ -395,16 +395,16 @@ impl Decode for char {
}
impl<'a, 'de: 'a> BorrowDecode<'de> for &'a [u8] {
fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
let len = super::decode_slice_len(&mut decoder)?;
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = super::decode_slice_len(decoder)?;
decoder.claim_bytes_read(len)?;
decoder.borrow_reader().take_bytes(len)
}
}
impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> {
fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<&[u8]>>())? {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
match super::decode_option_variant(decoder, core::any::type_name::<Option<&[u8]>>())? {
Some(_) => {
let val = BorrowDecode::borrow_decode(decoder)?;
Ok(Some(val))
@ -415,15 +415,15 @@ impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> {
}
impl<'a, 'de: 'a> BorrowDecode<'de> for &'a str {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: D) -> Result<Self, DecodeError> {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let slice = <&[u8]>::borrow_decode(decoder)?;
core::str::from_utf8(slice).map_err(DecodeError::Utf8)
}
}
impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a str> {
fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<&str>>())? {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
match super::decode_option_variant(decoder, core::any::type_name::<Option<&str>>())? {
Some(_) => {
let val = BorrowDecode::borrow_decode(decoder)?;
Ok(Some(val))
@ -437,9 +437,9 @@ impl<T, const N: usize> Decode for [T; N]
where
T: Decode + Sized + 'static,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
if !D::C::SKIP_FIXED_ARRAY_LENGTH {
let length = super::decode_slice_len(&mut decoder)?;
let length = super::decode_slice_len(decoder)?;
if length != N {
return Err(DecodeError::ArrayLengthMismatch {
found: length,
@ -464,7 +464,7 @@ where
let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| {
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
T::decode(&mut decoder)
T::decode(decoder)
}));
// result is only None if N does not match the values of `(0..N)`, which it always should
@ -475,13 +475,13 @@ where
}
impl Decode for () {
fn decode<D: Decoder>(_: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(_: &mut D) -> Result<Self, DecodeError> {
Ok(())
}
}
impl<T> Decode for core::marker::PhantomData<T> {
fn decode<D: Decoder>(_: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(_: &mut D) -> Result<Self, DecodeError> {
Ok(core::marker::PhantomData)
}
}
@ -490,8 +490,8 @@ impl<T> Decode for Option<T>
where
T: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<T>>())? {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match super::decode_option_variant(decoder, core::any::type_name::<Option<T>>())? {
Some(_) => {
let val = T::decode(decoder)?;
Ok(Some(val))
@ -506,8 +506,8 @@ where
T: Decode,
U: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let is_ok = u8::decode(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let is_ok = u8::decode(decoder)?;
match is_ok {
0 => {
let t = T::decode(decoder)?;
@ -530,7 +530,7 @@ impl<T> Decode for Cell<T>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = T::decode(decoder)?;
Ok(Cell::new(t))
}
@ -540,17 +540,17 @@ impl<T> Decode for RefCell<T>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = T::decode(decoder)?;
Ok(RefCell::new(t))
}
}
impl Decode for Duration {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
const NANOS_PER_SEC: u64 = 1_000_000_000;
let secs: u64 = Decode::decode(&mut decoder)?;
let nanos: u32 = Decode::decode(&mut decoder)?;
let secs: u64 = Decode::decode(decoder)?;
let nanos: u32 = Decode::decode(decoder)?;
if secs.checked_add(u64::from(nanos) / NANOS_PER_SEC).is_none() {
return Err(DecodeError::InvalidDuration { secs, nanos });
}
@ -562,9 +562,9 @@ impl<T> Decode for Range<T>
where
T: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let min = T::decode(&mut decoder)?;
let max = T::decode(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let min = T::decode(decoder)?;
let max = T::decode(decoder)?;
Ok(min..max)
}
}
@ -573,9 +573,9 @@ impl<T> Decode for RangeInclusive<T>
where
T: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let min = T::decode(&mut decoder)?;
let max = T::decode(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let min = T::decode(decoder)?;
let max = T::decode(decoder)?;
Ok(RangeInclusive::new(min, max))
}
}
@ -584,8 +584,8 @@ impl<T> Decode for Bound<T>
where
T: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
match u32::decode(&mut decoder)? {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match u32::decode(decoder)? {
0 => Ok(Bound::Unbounded),
1 => Ok(Bound::Included(T::decode(decoder)?)),
2 => Ok(Bound::Excluded(T::decode(decoder)?)),

16
src/de/mod.rs
View File

@ -25,7 +25,7 @@ pub use self::decoder::DecoderImpl;
/// This trait will be automatically implemented if you enable the `derive` feature and add `#[derive(bincode::Decode)]` to your type. Note that if the type contains any lifetimes, `BorrowDecode` will be implemented instead.
pub trait Decode: for<'de> BorrowDecode<'de> {
/// Attempt to decode this type with the given [Decode].
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError>;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError>;
}
/// Trait that makes a type able to be decoded, akin to serde's `Deserialize` trait.
@ -35,11 +35,11 @@ pub trait Decode: for<'de> BorrowDecode<'de> {
/// This trait will be automatically implemented if you enable the `derive` feature and add `#[derive(bincode::Decode)]` to a type with a lifetime.
pub trait BorrowDecode<'de>: Sized {
/// Attempt to decode this type with the given [BorrowDecode].
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: D) -> Result<Self, DecodeError>;
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError>;
}
impl<'de, T: Decode> BorrowDecode<'de> for T {
fn borrow_decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn borrow_decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
Decode::decode(decoder)
}
}
@ -100,8 +100,8 @@ pub trait Decoder: Sealed {
/// # }
/// # }
/// impl<T: Decode> Decode for Container<T> {
/// fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
/// let len = u64::decode(&mut decoder)? as usize;
/// fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
/// let len = u64::decode(decoder)? as usize;
/// // Make sure we don't allocate too much memory
/// decoder.claim_bytes_read(len * core::mem::size_of::<T>());
///
@ -109,7 +109,7 @@ pub trait Decoder: Sealed {
/// for _ in 0..len {
/// // un-claim the memory
/// decoder.unclaim_bytes_read(core::mem::size_of::<T>());
/// result.push(T::decode(&mut decoder)?)
/// result.push(T::decode(decoder)?)
/// }
/// Ok(result)
/// }
@ -170,7 +170,7 @@ where
/// Decodes only the option variant from the decoder. Will not read any more data than that.
#[inline]
pub(crate) fn decode_option_variant<D: Decoder>(
decoder: D,
decoder: &mut D,
type_name: &'static str,
) -> Result<Option<()>, DecodeError> {
let is_some = u8::decode(decoder)?;
@ -187,6 +187,6 @@ pub(crate) fn decode_option_variant<D: Decoder>(
/// Decodes the length of any slice, container, etc from the decoder
#[inline]
pub(crate) fn decode_slice_len<D: Decoder>(decoder: D) -> Result<usize, DecodeError> {
pub(crate) fn decode_slice_len<D: Decoder>(decoder: &mut D) -> Result<usize, DecodeError> {
u64::decode(decoder).map(|v| v as usize)
}

22
src/features/atomic.rs
View File

@ -11,7 +11,7 @@ impl Encode for AtomicBool {
}
impl Decode for AtomicBool {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicBool::new(Decode::decode(decoder)?))
}
}
@ -23,7 +23,7 @@ impl Encode for AtomicU8 {
}
impl Decode for AtomicU8 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicU8::new(Decode::decode(decoder)?))
}
}
@ -35,7 +35,7 @@ impl Encode for AtomicU16 {
}
impl Decode for AtomicU16 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicU16::new(Decode::decode(decoder)?))
}
}
@ -47,7 +47,7 @@ impl Encode for AtomicU32 {
}
impl Decode for AtomicU32 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicU32::new(Decode::decode(decoder)?))
}
}
@ -59,7 +59,7 @@ impl Encode for AtomicU64 {
}
impl Decode for AtomicU64 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicU64::new(Decode::decode(decoder)?))
}
}
@ -71,7 +71,7 @@ impl Encode for AtomicUsize {
}
impl Decode for AtomicUsize {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicUsize::new(Decode::decode(decoder)?))
}
}
@ -83,7 +83,7 @@ impl Encode for AtomicI8 {
}
impl Decode for AtomicI8 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicI8::new(Decode::decode(decoder)?))
}
}
@ -95,7 +95,7 @@ impl Encode for AtomicI16 {
}
impl Decode for AtomicI16 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicI16::new(Decode::decode(decoder)?))
}
}
@ -107,7 +107,7 @@ impl Encode for AtomicI32 {
}
impl Decode for AtomicI32 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicI32::new(Decode::decode(decoder)?))
}
}
@ -119,7 +119,7 @@ impl Encode for AtomicI64 {
}
impl Decode for AtomicI64 {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicI64::new(Decode::decode(decoder)?))
}
}
@ -131,7 +131,7 @@ impl Encode for AtomicIsize {
}
impl Decode for AtomicIsize {
fn decode<D: crate::de::Decoder>(decoder: D) -> Result<Self, crate::error::DecodeError> {
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
Ok(AtomicIsize::new(Decode::decode(decoder)?))
}
}

46
src/features/impl_alloc.rs
View File

@ -50,8 +50,8 @@ impl<T> Decode for BinaryHeap<T>
where
T: Decode + Ord,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut map = BinaryHeap::with_capacity(len);
@ -59,7 +59,7 @@ where
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(&mut decoder)?;
let key = T::decode(decoder)?;
map.push(key);
}
Ok(map)
@ -84,8 +84,8 @@ where
K: Decode + Ord,
V: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<(K, V)>(len)?;
let mut map = BTreeMap::new();
@ -93,8 +93,8 @@ where
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
let key = K::decode(&mut decoder)?;
let value = V::decode(&mut decoder)?;
let key = K::decode(decoder)?;
let value = V::decode(decoder)?;
map.insert(key, value);
}
Ok(map)
@ -120,8 +120,8 @@ impl<T> Decode for BTreeSet<T>
where
T: Decode + Ord,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut map = BTreeSet::new();
@ -129,7 +129,7 @@ where
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(&mut decoder)?;
let key = T::decode(decoder)?;
map.insert(key);
}
Ok(map)
@ -153,8 +153,8 @@ impl<T> Decode for VecDeque<T>
where
T: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut map = VecDeque::with_capacity(len);
@ -162,7 +162,7 @@ where
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(&mut decoder)?;
let key = T::decode(decoder)?;
map.push_back(key);
}
Ok(map)
@ -186,8 +186,8 @@ impl<T> Decode for Vec<T>
where
T: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?;
let mut vec = Vec::with_capacity(len);
@ -195,7 +195,7 @@ where
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>());
vec.push(T::decode(&mut decoder)?);
vec.push(T::decode(decoder)?);
}
Ok(vec)
}
@ -215,7 +215,7 @@ where
}
impl Decode for String {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let bytes = Vec::<u8>::decode(decoder)?;
String::from_utf8(bytes).map_err(|e| DecodeError::Utf8(e.utf8_error()))
}
@ -231,7 +231,7 @@ impl<T> Decode for Box<T>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = T::decode(decoder)?;
Ok(Box::new(t))
}
@ -250,7 +250,7 @@ impl<T> Decode for Box<[T]>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let vec = Vec::decode(decoder)?;
Ok(vec.into_boxed_slice())
}
@ -277,7 +277,7 @@ where
// where
// T: BorrowDecode<'cow>,
// {
// fn borrow_decode<D: crate::de::BorrowDecoder<'cow>>(decoder: D) -> Result<Self, DecodeError> {
// fn borrow_decode<D: crate::de::BorrowDecoder<'cow>>(decoder: &mut D) -> Result<Self, DecodeError> {
// let t = T::borrow_decode(decoder)?;
// Ok(Cow::Borrowed(t))
// }
@ -288,7 +288,7 @@ where
T: ToOwned,
<T as ToOwned>::Owned: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = <T as ToOwned>::Owned::decode(decoder)?;
Ok(Cow::Owned(t))
}
@ -307,7 +307,7 @@ impl<T> Decode for Rc<T>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = T::decode(decoder)?;
Ok(Rc::new(t))
}
@ -327,7 +327,7 @@ impl<T> Decode for Arc<T>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = T::decode(decoder)?;
Ok(Arc::new(t))
}

42
src/features/impl_std.rs
View File

@ -114,7 +114,7 @@ impl<'a> Encode for &'a CStr {
}
impl<'de> BorrowDecode<'de> for &'de CStr {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: D) -> Result<Self, DecodeError> {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let bytes = <&[u8]>::borrow_decode(decoder)?;
CStr::from_bytes_with_nul(bytes).map_err(|e| DecodeError::CStrNulError { inner: e })
}
@ -127,7 +127,7 @@ impl Encode for CString {
}
impl Decode for CString {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
// BlockedTODO: https://github.com/rust-lang/rust/issues/73179
// use `from_vec_with_nul` instead, combined with:
// let bytes = std::vec::Vec::<u8>::decode(decoder)?;
@ -156,7 +156,7 @@ impl<T> Decode for Mutex<T>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = T::decode(decoder)?;
Ok(Mutex::new(t))
}
@ -178,7 +178,7 @@ impl<T> Decode for RwLock<T>
where
T: Decode,
{
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let t = T::decode(decoder)?;
Ok(RwLock::new(t))
}
@ -197,7 +197,7 @@ impl Encode for SystemTime {
}
impl Decode for SystemTime {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let duration = Duration::decode(decoder)?;
match SystemTime::UNIX_EPOCH.checked_add(duration) {
Some(t) => Ok(t),
@ -216,7 +216,7 @@ impl Encode for &'_ Path {
}
impl<'de> BorrowDecode<'de> for &'de Path {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: D) -> Result<Self, DecodeError> {
fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let str = <&'de str>::borrow_decode(decoder)?;
Ok(Path::new(str))
}
@ -229,7 +229,7 @@ impl Encode for PathBuf {
}
impl Decode for PathBuf {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let string = std::string::String::decode(decoder)?;
Ok(string.into())
}
@ -251,8 +251,8 @@ impl Encode for IpAddr {
}
impl Decode for IpAddr {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
match u32::decode(&mut decoder)? {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match u32::decode(decoder)? {
0 => Ok(IpAddr::V4(Ipv4Addr::decode(decoder)?)),
1 => Ok(IpAddr::V6(Ipv6Addr::decode(decoder)?)),
found => Err(DecodeError::UnexpectedVariant {
@ -271,7 +271,7 @@ impl Encode for Ipv4Addr {
}
impl Decode for Ipv4Addr {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
Ok(Self::from(<[u8; 4]>::decode(decoder)?))
}
}
@ -283,7 +283,7 @@ impl Encode for Ipv6Addr {
}
impl Decode for Ipv6Addr {
fn decode<D: Decoder>(decoder: D) -> Result<Self, DecodeError> {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
Ok(Self::from(<[u8; 16]>::decode(decoder)?))
}
}
@ -304,8 +304,8 @@ impl Encode for SocketAddr {
}
impl Decode for SocketAddr {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
match u32::decode(&mut decoder)? {
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match u32::decode(decoder)? {
0 => Ok(SocketAddr::V4(SocketAddrV4::decode(decoder)?)),
1 => Ok(SocketAddr::V6(SocketAddrV6::decode(decoder)?)),
found => Err(DecodeError::UnexpectedVariant {
@ -325,8 +325,8 @@ impl Encode for SocketAddrV4 {
}
impl Decode for SocketAddrV4 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let ip = Ipv4Addr::decode(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let ip = Ipv4Addr::decode(decoder)?;
let port = u16::decode(decoder)?;
Ok(Self::new(ip, port))
}
@ -340,8 +340,8 @@ impl Encode for SocketAddrV6 {
}
impl Decode for SocketAddrV6 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let ip = Ipv6Addr::decode(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let ip = Ipv6Addr::decode(decoder)?;
let port = u16::decode(decoder)?;
Ok(Self::new(ip, port, 0, 0))
}
@ -370,8 +370,8 @@ where
K: Decode + Eq + std::hash::Hash,
V: Decode,
{
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?;
fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<(K, V)>(len)?;
let mut map = HashMap::with_capacity(len);
@ -379,8 +379,8 @@ where
// See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
let k = K::decode(&mut decoder)?;
let v = V::decode(&mut decoder)?;
let k = K::decode(decoder)?;
let v = V::decode(decoder)?;
map.insert(k, v);
}
Ok(map)

8
src/features/serde/mod.rs
View File

@ -101,8 +101,8 @@ impl<T> crate::Decode for Compat<T>
where
T: serde_incl::de::DeserializeOwned,
{
fn decode<D: crate::de::Decoder>(mut decoder: D) -> Result<Self, crate::error::DecodeError> {
let serde_decoder = de_owned::SerdeDecoder { de: &mut decoder };
fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
let serde_decoder = de_owned::SerdeDecoder { de: decoder };
T::deserialize(serde_decoder).map(Compat)
}
}
@ -134,10 +134,10 @@ where
T: serde_incl::de::Deserialize<'de>,
{
fn borrow_decode<D: crate::de::BorrowDecoder<'de>>(
mut decoder: D,
decoder: &mut D,
) -> Result<Self, crate::error::DecodeError> {
let serde_decoder = de_borrowed::SerdeDecoder {
de: &mut decoder,
de: decoder,
pd: core::marker::PhantomData,
};
T::deserialize(serde_decoder).map(BorrowCompat)

6
tests/alloc.rs
View File

@ -30,11 +30,11 @@ impl bincode::enc::Encode for Foo {
impl bincode::Decode for Foo {
fn decode<D: bincode::de::Decoder>(
mut decoder: D,
decoder: &mut D,
) -> Result<Self, bincode::error::DecodeError> {
Ok(Self {
a: bincode::Decode::decode(&mut decoder)?,
b: bincode::Decode::decode(&mut decoder)?,
a: bincode::Decode::decode(decoder)?,
b: bincode::Decode::decode(decoder)?,
})
}
}

3
tests/issues.rs
View File

@ -5,3 +5,6 @@ mod issue_431;
#[path = "issues/issue_427.rs"]
mod issue_427;
#[path = "issues/issue_467.rs"]
mod issue_467;

16
tests/issues/issue_467.rs Normal file
View File

@ -0,0 +1,16 @@
#![cfg(all(feature = "std", feature = "derive"))]
extern crate std;
use std::collections::BTreeMap;
#[derive(bincode::Decode)]
struct AllTypes(BTreeMap<u8, AllTypes>);
#[test]
fn test_issue_467() {
let _result: Result<(AllTypes, _), _> = bincode::decode_from_slice(
&[],
bincode::config::Configuration::standard().with_limit::<1024>(),
);
}

6
tests/std.rs
View File

@ -32,11 +32,11 @@ impl bincode::enc::Encode for Foo {
impl bincode::Decode for Foo {
fn decode<D: bincode::de::Decoder>(
mut decoder: D,
decoder: &mut D,
) -> Result<Self, bincode::error::DecodeError> {
Ok(Self {
a: bincode::Decode::decode(&mut decoder)?,
b: bincode::Decode::decode(&mut decoder)?,
a: bincode::Decode::decode(decoder)?,
b: bincode::Decode::decode(decoder)?,
})
}
}