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

16
derive/src/derive_struct.rs
View File

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

16
src/de/impl_tuples.rs
View File

@ -5,7 +5,7 @@ impl<A> Decode for (A,)
where where
A: Decode, 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)?,)) Ok((A::decode(&mut decoder)?,))
} }
} }
@ -15,7 +15,7 @@ where
A: Decode, A: Decode,
B: 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)?)) Ok((A::decode(&mut decoder)?, B::decode(&mut decoder)?))
} }
} }
@ -26,7 +26,7 @@ where
B: Decode, B: Decode,
C: 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(( Ok((
A::decode(&mut decoder)?, A::decode(&mut decoder)?,
B::decode(&mut decoder)?, B::decode(&mut decoder)?,
@ -42,7 +42,7 @@ where
C: Decode, C: Decode,
D: 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(( Ok((
A::decode(&mut decoder)?, A::decode(&mut decoder)?,
B::decode(&mut decoder)?, B::decode(&mut decoder)?,
@ -60,7 +60,7 @@ where
D: Decode, D: Decode,
E: 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(( Ok((
A::decode(&mut decoder)?, A::decode(&mut decoder)?,
B::decode(&mut decoder)?, B::decode(&mut decoder)?,
@ -80,7 +80,7 @@ where
E: Decode, E: Decode,
F: 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(( Ok((
A::decode(&mut decoder)?, A::decode(&mut decoder)?,
B::decode(&mut decoder)?, B::decode(&mut decoder)?,
@ -102,7 +102,7 @@ where
F: Decode, F: Decode,
G: 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(( Ok((
A::decode(&mut decoder)?, A::decode(&mut decoder)?,
B::decode(&mut decoder)?, B::decode(&mut decoder)?,
@ -126,7 +126,7 @@ where
G: Decode, G: Decode,
H: 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(( Ok((
A::decode(&mut decoder)?, A::decode(&mut decoder)?,
B::decode(&mut decoder)?, B::decode(&mut decoder)?,

114
src/de/impls.rs
View File

@ -21,7 +21,7 @@ use core::{
}; };
impl Decode for bool { 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)? { match u8::decode(decoder)? {
0 => Ok(false), 0 => Ok(false),
1 => Ok(true), 1 => Ok(true),
@ -32,7 +32,7 @@ impl Decode for bool {
impl Decode for u8 { impl Decode for u8 {
#[inline] #[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)?; decoder.claim_bytes_read(1)?;
if let Some(buf) = decoder.reader().peek_read(1) { if let Some(buf) = decoder.reader().peek_read(1) {
let byte = buf[0]; let byte = buf[0];
@ -47,7 +47,7 @@ impl Decode for u8 {
} }
impl Decode for NonZeroU8 { 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 { NonZeroU8::new(u8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U8, non_zero_type: IntegerType::U8,
}) })
@ -55,7 +55,7 @@ impl Decode for NonZeroU8 {
} }
impl Decode for u16 { 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)?; decoder.claim_bytes_read(2)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -74,7 +74,7 @@ impl Decode for u16 {
} }
impl Decode for NonZeroU16 { 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 { NonZeroU16::new(u16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U16, non_zero_type: IntegerType::U16,
}) })
@ -82,7 +82,7 @@ impl Decode for NonZeroU16 {
} }
impl Decode for u32 { 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)?; decoder.claim_bytes_read(4)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -101,7 +101,7 @@ impl Decode for u32 {
} }
impl Decode for NonZeroU32 { 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 { NonZeroU32::new(u32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U32, non_zero_type: IntegerType::U32,
}) })
@ -109,7 +109,7 @@ impl Decode for NonZeroU32 {
} }
impl Decode for u64 { 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)?; decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -128,7 +128,7 @@ impl Decode for u64 {
} }
impl Decode for NonZeroU64 { 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 { NonZeroU64::new(u64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U64, non_zero_type: IntegerType::U64,
}) })
@ -136,7 +136,7 @@ impl Decode for NonZeroU64 {
} }
impl Decode for u128 { 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)?; decoder.claim_bytes_read(16)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -155,7 +155,7 @@ impl Decode for u128 {
} }
impl Decode for NonZeroU128 { 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 { NonZeroU128::new(u128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::U128, non_zero_type: IntegerType::U128,
}) })
@ -163,7 +163,7 @@ impl Decode for NonZeroU128 {
} }
impl Decode for usize { 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)?; decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -182,7 +182,7 @@ impl Decode for usize {
} }
impl Decode for NonZeroUsize { 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 { NonZeroUsize::new(usize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::Usize, non_zero_type: IntegerType::Usize,
}) })
@ -190,7 +190,7 @@ impl Decode for NonZeroUsize {
} }
impl Decode for i8 { 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)?; decoder.claim_bytes_read(1)?;
let mut bytes = [0u8; 1]; let mut bytes = [0u8; 1];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
@ -199,7 +199,7 @@ impl Decode for i8 {
} }
impl Decode for NonZeroI8 { 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 { NonZeroI8::new(i8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I8, non_zero_type: IntegerType::I8,
}) })
@ -207,7 +207,7 @@ impl Decode for NonZeroI8 {
} }
impl Decode for i16 { 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)?; decoder.claim_bytes_read(2)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -226,7 +226,7 @@ impl Decode for i16 {
} }
impl Decode for NonZeroI16 { 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 { NonZeroI16::new(i16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I16, non_zero_type: IntegerType::I16,
}) })
@ -234,7 +234,7 @@ impl Decode for NonZeroI16 {
} }
impl Decode for i32 { 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)?; decoder.claim_bytes_read(4)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -253,7 +253,7 @@ impl Decode for i32 {
} }
impl Decode for NonZeroI32 { 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 { NonZeroI32::new(i32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I32, non_zero_type: IntegerType::I32,
}) })
@ -261,7 +261,7 @@ impl Decode for NonZeroI32 {
} }
impl Decode for i64 { 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)?; decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -280,7 +280,7 @@ impl Decode for i64 {
} }
impl Decode for NonZeroI64 { 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 { NonZeroI64::new(i64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I64, non_zero_type: IntegerType::I64,
}) })
@ -288,7 +288,7 @@ impl Decode for NonZeroI64 {
} }
impl Decode for i128 { 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)?; decoder.claim_bytes_read(16)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -307,7 +307,7 @@ impl Decode for i128 {
} }
impl Decode for NonZeroI128 { 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 { NonZeroI128::new(i128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::I128, non_zero_type: IntegerType::I128,
}) })
@ -315,7 +315,7 @@ impl Decode for NonZeroI128 {
} }
impl Decode for isize { 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)?; decoder.claim_bytes_read(8)?;
match D::C::INT_ENCODING { match D::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
@ -334,7 +334,7 @@ impl Decode for isize {
} }
impl Decode for NonZeroIsize { 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 { NonZeroIsize::new(isize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
non_zero_type: IntegerType::Isize, non_zero_type: IntegerType::Isize,
}) })
@ -342,7 +342,7 @@ impl Decode for NonZeroIsize {
} }
impl Decode for f32 { 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)?; decoder.claim_bytes_read(4)?;
let mut bytes = [0u8; 4]; let mut bytes = [0u8; 4];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
@ -354,7 +354,7 @@ impl Decode for f32 {
} }
impl Decode for f64 { 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)?; decoder.claim_bytes_read(8)?;
let mut bytes = [0u8; 8]; let mut bytes = [0u8; 8];
decoder.reader().read(&mut bytes)?; decoder.reader().read(&mut bytes)?;
@ -366,7 +366,7 @@ impl Decode for f64 {
} }
impl Decode for char { 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]; let mut array = [0u8; 4];
// Look at the first byte to see how many bytes must be read // 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] { impl<'a, 'de: 'a> BorrowDecode<'de> for &'a [u8] {
fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> { fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = super::decode_slice_len(&mut decoder)?; let len = super::decode_slice_len(decoder)?;
decoder.claim_bytes_read(len)?; decoder.claim_bytes_read(len)?;
decoder.borrow_reader().take_bytes(len) decoder.borrow_reader().take_bytes(len)
} }
} }
impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> { impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> {
fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> { fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<&[u8]>>())? { match super::decode_option_variant(decoder, core::any::type_name::<Option<&[u8]>>())? {
Some(_) => { Some(_) => {
let val = BorrowDecode::borrow_decode(decoder)?; let val = BorrowDecode::borrow_decode(decoder)?;
Ok(Some(val)) 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 { 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)?; let slice = <&[u8]>::borrow_decode(decoder)?;
core::str::from_utf8(slice).map_err(DecodeError::Utf8) core::str::from_utf8(slice).map_err(DecodeError::Utf8)
} }
} }
impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a str> { impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a str> {
fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> { fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<&str>>())? { match super::decode_option_variant(decoder, core::any::type_name::<Option<&str>>())? {
Some(_) => { Some(_) => {
let val = BorrowDecode::borrow_decode(decoder)?; let val = BorrowDecode::borrow_decode(decoder)?;
Ok(Some(val)) Ok(Some(val))
@ -437,9 +437,9 @@ impl<T, const N: usize> Decode for [T; N]
where where
T: Decode + Sized + 'static, 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 { 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 { if length != N {
return Err(DecodeError::ArrayLengthMismatch { return Err(DecodeError::ArrayLengthMismatch {
found: length, found: length,
@ -464,7 +464,7 @@ where
let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| { 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 // See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>()); 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 // 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 () { impl Decode for () {
fn decode<D: Decoder>(_: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(_: &mut D) -> Result<Self, DecodeError> {
Ok(()) Ok(())
} }
} }
impl<T> Decode for core::marker::PhantomData<T> { 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) Ok(core::marker::PhantomData)
} }
} }
@ -490,8 +490,8 @@ impl<T> Decode for Option<T>
where where
T: Decode, T: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<T>>())? { match super::decode_option_variant(decoder, core::any::type_name::<Option<T>>())? {
Some(_) => { Some(_) => {
let val = T::decode(decoder)?; let val = T::decode(decoder)?;
Ok(Some(val)) Ok(Some(val))
@ -506,8 +506,8 @@ where
T: Decode, T: Decode,
U: Decode, U: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let is_ok = u8::decode(&mut decoder)?; let is_ok = u8::decode(decoder)?;
match is_ok { match is_ok {
0 => { 0 => {
let t = T::decode(decoder)?; let t = T::decode(decoder)?;
@ -530,7 +530,7 @@ impl<T> Decode for Cell<T>
where where
T: Decode, 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)?; let t = T::decode(decoder)?;
Ok(Cell::new(t)) Ok(Cell::new(t))
} }
@ -540,17 +540,17 @@ impl<T> Decode for RefCell<T>
where where
T: Decode, 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)?; let t = T::decode(decoder)?;
Ok(RefCell::new(t)) Ok(RefCell::new(t))
} }
} }
impl Decode for Duration { 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; const NANOS_PER_SEC: u64 = 1_000_000_000;
let secs: u64 = Decode::decode(&mut decoder)?; let secs: u64 = Decode::decode(decoder)?;
let nanos: u32 = Decode::decode(&mut decoder)?; let nanos: u32 = Decode::decode(decoder)?;
if secs.checked_add(u64::from(nanos) / NANOS_PER_SEC).is_none() { if secs.checked_add(u64::from(nanos) / NANOS_PER_SEC).is_none() {
return Err(DecodeError::InvalidDuration { secs, nanos }); return Err(DecodeError::InvalidDuration { secs, nanos });
} }
@ -562,9 +562,9 @@ impl<T> Decode for Range<T>
where where
T: Decode, T: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let min = T::decode(&mut decoder)?; let min = T::decode(decoder)?;
let max = T::decode(&mut decoder)?; let max = T::decode(decoder)?;
Ok(min..max) Ok(min..max)
} }
} }
@ -573,9 +573,9 @@ impl<T> Decode for RangeInclusive<T>
where where
T: Decode, T: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let min = T::decode(&mut decoder)?; let min = T::decode(decoder)?;
let max = T::decode(&mut decoder)?; let max = T::decode(decoder)?;
Ok(RangeInclusive::new(min, max)) Ok(RangeInclusive::new(min, max))
} }
} }
@ -584,8 +584,8 @@ impl<T> Decode for Bound<T>
where where
T: Decode, T: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match u32::decode(&mut decoder)? { match u32::decode(decoder)? {
0 => Ok(Bound::Unbounded), 0 => Ok(Bound::Unbounded),
1 => Ok(Bound::Included(T::decode(decoder)?)), 1 => Ok(Bound::Included(T::decode(decoder)?)),
2 => Ok(Bound::Excluded(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. /// 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> { pub trait Decode: for<'de> BorrowDecode<'de> {
/// Attempt to decode this type with the given [Decode]. /// 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. /// 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. /// 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 { pub trait BorrowDecode<'de>: Sized {
/// Attempt to decode this type with the given [BorrowDecode]. /// 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 { 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) Decode::decode(decoder)
} }
} }
@ -100,8 +100,8 @@ pub trait Decoder: Sealed {
/// # } /// # }
/// # } /// # }
/// impl<T: Decode> Decode for Container<T> { /// impl<T: Decode> Decode for Container<T> {
/// fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { /// fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
/// let len = u64::decode(&mut decoder)? as usize; /// let len = u64::decode(decoder)? as usize;
/// // Make sure we don't allocate too much memory /// // Make sure we don't allocate too much memory
/// decoder.claim_bytes_read(len * core::mem::size_of::<T>()); /// decoder.claim_bytes_read(len * core::mem::size_of::<T>());
/// ///
@ -109,7 +109,7 @@ pub trait Decoder: Sealed {
/// for _ in 0..len { /// for _ in 0..len {
/// // un-claim the memory /// // un-claim the memory
/// decoder.unclaim_bytes_read(core::mem::size_of::<T>()); /// decoder.unclaim_bytes_read(core::mem::size_of::<T>());
/// result.push(T::decode(&mut decoder)?) /// result.push(T::decode(decoder)?)
/// } /// }
/// Ok(result) /// Ok(result)
/// } /// }
@ -170,7 +170,7 @@ where
/// Decodes only the option variant from the decoder. Will not read any more data than that. /// Decodes only the option variant from the decoder. Will not read any more data than that.
#[inline] #[inline]
pub(crate) fn decode_option_variant<D: Decoder>( pub(crate) fn decode_option_variant<D: Decoder>(
decoder: D, decoder: &mut D,
type_name: &'static str, type_name: &'static str,
) -> Result<Option<()>, DecodeError> { ) -> Result<Option<()>, DecodeError> {
let is_some = u8::decode(decoder)?; 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 /// Decodes the length of any slice, container, etc from the decoder
#[inline] #[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) 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 { 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)?)) Ok(AtomicBool::new(Decode::decode(decoder)?))
} }
} }
@ -23,7 +23,7 @@ impl Encode for AtomicU8 {
} }
impl Decode 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)?)) Ok(AtomicU8::new(Decode::decode(decoder)?))
} }
} }
@ -35,7 +35,7 @@ impl Encode for AtomicU16 {
} }
impl Decode 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)?)) Ok(AtomicU16::new(Decode::decode(decoder)?))
} }
} }
@ -47,7 +47,7 @@ impl Encode for AtomicU32 {
} }
impl Decode 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)?)) Ok(AtomicU32::new(Decode::decode(decoder)?))
} }
} }
@ -59,7 +59,7 @@ impl Encode for AtomicU64 {
} }
impl Decode 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)?)) Ok(AtomicU64::new(Decode::decode(decoder)?))
} }
} }
@ -71,7 +71,7 @@ impl Encode for AtomicUsize {
} }
impl Decode 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)?)) Ok(AtomicUsize::new(Decode::decode(decoder)?))
} }
} }
@ -83,7 +83,7 @@ impl Encode for AtomicI8 {
} }
impl Decode 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)?)) Ok(AtomicI8::new(Decode::decode(decoder)?))
} }
} }
@ -95,7 +95,7 @@ impl Encode for AtomicI16 {
} }
impl Decode 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)?)) Ok(AtomicI16::new(Decode::decode(decoder)?))
} }
} }
@ -107,7 +107,7 @@ impl Encode for AtomicI32 {
} }
impl Decode 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)?)) Ok(AtomicI32::new(Decode::decode(decoder)?))
} }
} }
@ -119,7 +119,7 @@ impl Encode for AtomicI64 {
} }
impl Decode 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)?)) Ok(AtomicI64::new(Decode::decode(decoder)?))
} }
} }
@ -131,7 +131,7 @@ impl Encode for AtomicIsize {
} }
impl Decode 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)?)) 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 where
T: Decode + Ord, T: Decode + Ord,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?; let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?; decoder.claim_container_read::<T>(len)?;
let mut map = BinaryHeap::with_capacity(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 // See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>()); decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(&mut decoder)?; let key = T::decode(decoder)?;
map.push(key); map.push(key);
} }
Ok(map) Ok(map)
@ -84,8 +84,8 @@ where
K: Decode + Ord, K: Decode + Ord,
V: Decode, V: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?; let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<(K, V)>(len)?; decoder.claim_container_read::<(K, V)>(len)?;
let mut map = BTreeMap::new(); 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 // 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)>()); decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
let key = K::decode(&mut decoder)?; let key = K::decode(decoder)?;
let value = V::decode(&mut decoder)?; let value = V::decode(decoder)?;
map.insert(key, value); map.insert(key, value);
} }
Ok(map) Ok(map)
@ -120,8 +120,8 @@ impl<T> Decode for BTreeSet<T>
where where
T: Decode + Ord, T: Decode + Ord,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?; let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?; decoder.claim_container_read::<T>(len)?;
let mut map = BTreeSet::new(); 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 // See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>()); decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(&mut decoder)?; let key = T::decode(decoder)?;
map.insert(key); map.insert(key);
} }
Ok(map) Ok(map)
@ -153,8 +153,8 @@ impl<T> Decode for VecDeque<T>
where where
T: Decode, T: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?; let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?; decoder.claim_container_read::<T>(len)?;
let mut map = VecDeque::with_capacity(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 // See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>()); decoder.unclaim_bytes_read(core::mem::size_of::<T>());
let key = T::decode(&mut decoder)?; let key = T::decode(decoder)?;
map.push_back(key); map.push_back(key);
} }
Ok(map) Ok(map)
@ -186,8 +186,8 @@ impl<T> Decode for Vec<T>
where where
T: Decode, T: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?; let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<T>(len)?; decoder.claim_container_read::<T>(len)?;
let mut vec = Vec::with_capacity(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 // See the documentation on `unclaim_bytes_read` as to why we're doing this here
decoder.unclaim_bytes_read(core::mem::size_of::<T>()); decoder.unclaim_bytes_read(core::mem::size_of::<T>());
vec.push(T::decode(&mut decoder)?); vec.push(T::decode(decoder)?);
} }
Ok(vec) Ok(vec)
} }
@ -215,7 +215,7 @@ where
} }
impl Decode for String { 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)?; let bytes = Vec::<u8>::decode(decoder)?;
String::from_utf8(bytes).map_err(|e| DecodeError::Utf8(e.utf8_error())) String::from_utf8(bytes).map_err(|e| DecodeError::Utf8(e.utf8_error()))
} }
@ -231,7 +231,7 @@ impl<T> Decode for Box<T>
where where
T: Decode, 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)?; let t = T::decode(decoder)?;
Ok(Box::new(t)) Ok(Box::new(t))
} }
@ -250,7 +250,7 @@ impl<T> Decode for Box<[T]>
where where
T: Decode, 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)?; let vec = Vec::decode(decoder)?;
Ok(vec.into_boxed_slice()) Ok(vec.into_boxed_slice())
} }
@ -277,7 +277,7 @@ where
// where // where
// T: BorrowDecode<'cow>, // 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)?; // let t = T::borrow_decode(decoder)?;
// Ok(Cow::Borrowed(t)) // Ok(Cow::Borrowed(t))
// } // }
@ -288,7 +288,7 @@ where
T: ToOwned, T: ToOwned,
<T as ToOwned>::Owned: Decode, <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)?; let t = <T as ToOwned>::Owned::decode(decoder)?;
Ok(Cow::Owned(t)) Ok(Cow::Owned(t))
} }
@ -307,7 +307,7 @@ impl<T> Decode for Rc<T>
where where
T: Decode, 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)?; let t = T::decode(decoder)?;
Ok(Rc::new(t)) Ok(Rc::new(t))
} }
@ -327,7 +327,7 @@ impl<T> Decode for Arc<T>
where where
T: Decode, 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)?; let t = T::decode(decoder)?;
Ok(Arc::new(t)) 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 { 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)?; let bytes = <&[u8]>::borrow_decode(decoder)?;
CStr::from_bytes_with_nul(bytes).map_err(|e| DecodeError::CStrNulError { inner: e }) 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 { 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 // BlockedTODO: https://github.com/rust-lang/rust/issues/73179
// use `from_vec_with_nul` instead, combined with: // use `from_vec_with_nul` instead, combined with:
// let bytes = std::vec::Vec::<u8>::decode(decoder)?; // let bytes = std::vec::Vec::<u8>::decode(decoder)?;
@ -156,7 +156,7 @@ impl<T> Decode for Mutex<T>
where where
T: Decode, 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)?; let t = T::decode(decoder)?;
Ok(Mutex::new(t)) Ok(Mutex::new(t))
} }
@ -178,7 +178,7 @@ impl<T> Decode for RwLock<T>
where where
T: Decode, 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)?; let t = T::decode(decoder)?;
Ok(RwLock::new(t)) Ok(RwLock::new(t))
} }
@ -197,7 +197,7 @@ impl Encode for SystemTime {
} }
impl Decode 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)?; let duration = Duration::decode(decoder)?;
match SystemTime::UNIX_EPOCH.checked_add(duration) { match SystemTime::UNIX_EPOCH.checked_add(duration) {
Some(t) => Ok(t), Some(t) => Ok(t),
@ -216,7 +216,7 @@ impl Encode for &'_ Path {
} }
impl<'de> BorrowDecode<'de> for &'de 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)?; let str = <&'de str>::borrow_decode(decoder)?;
Ok(Path::new(str)) Ok(Path::new(str))
} }
@ -229,7 +229,7 @@ impl Encode for PathBuf {
} }
impl Decode 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)?; let string = std::string::String::decode(decoder)?;
Ok(string.into()) Ok(string.into())
} }
@ -251,8 +251,8 @@ impl Encode for IpAddr {
} }
impl Decode for IpAddr { impl Decode for IpAddr {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match u32::decode(&mut decoder)? { match u32::decode(decoder)? {
0 => Ok(IpAddr::V4(Ipv4Addr::decode(decoder)?)), 0 => Ok(IpAddr::V4(Ipv4Addr::decode(decoder)?)),
1 => Ok(IpAddr::V6(Ipv6Addr::decode(decoder)?)), 1 => Ok(IpAddr::V6(Ipv6Addr::decode(decoder)?)),
found => Err(DecodeError::UnexpectedVariant { found => Err(DecodeError::UnexpectedVariant {
@ -271,7 +271,7 @@ impl Encode for Ipv4Addr {
} }
impl Decode 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)?)) Ok(Self::from(<[u8; 4]>::decode(decoder)?))
} }
} }
@ -283,7 +283,7 @@ impl Encode for Ipv6Addr {
} }
impl Decode 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)?)) Ok(Self::from(<[u8; 16]>::decode(decoder)?))
} }
} }
@ -304,8 +304,8 @@ impl Encode for SocketAddr {
} }
impl Decode for SocketAddr { impl Decode for SocketAddr {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
match u32::decode(&mut decoder)? { match u32::decode(decoder)? {
0 => Ok(SocketAddr::V4(SocketAddrV4::decode(decoder)?)), 0 => Ok(SocketAddr::V4(SocketAddrV4::decode(decoder)?)),
1 => Ok(SocketAddr::V6(SocketAddrV6::decode(decoder)?)), 1 => Ok(SocketAddr::V6(SocketAddrV6::decode(decoder)?)),
found => Err(DecodeError::UnexpectedVariant { found => Err(DecodeError::UnexpectedVariant {
@ -325,8 +325,8 @@ impl Encode for SocketAddrV4 {
} }
impl Decode for SocketAddrV4 { impl Decode for SocketAddrV4 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let ip = Ipv4Addr::decode(&mut decoder)?; let ip = Ipv4Addr::decode(decoder)?;
let port = u16::decode(decoder)?; let port = u16::decode(decoder)?;
Ok(Self::new(ip, port)) Ok(Self::new(ip, port))
} }
@ -340,8 +340,8 @@ impl Encode for SocketAddrV6 {
} }
impl Decode for SocketAddrV6 { impl Decode for SocketAddrV6 {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let ip = Ipv6Addr::decode(&mut decoder)?; let ip = Ipv6Addr::decode(decoder)?;
let port = u16::decode(decoder)?; let port = u16::decode(decoder)?;
Ok(Self::new(ip, port, 0, 0)) Ok(Self::new(ip, port, 0, 0))
} }
@ -370,8 +370,8 @@ where
K: Decode + Eq + std::hash::Hash, K: Decode + Eq + std::hash::Hash,
V: Decode, V: Decode,
{ {
fn decode<D: Decoder>(mut decoder: D) -> Result<Self, DecodeError> { fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
let len = crate::de::decode_slice_len(&mut decoder)?; let len = crate::de::decode_slice_len(decoder)?;
decoder.claim_container_read::<(K, V)>(len)?; decoder.claim_container_read::<(K, V)>(len)?;
let mut map = HashMap::with_capacity(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 // 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)>()); decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>());
let k = K::decode(&mut decoder)?; let k = K::decode(decoder)?;
let v = V::decode(&mut decoder)?; let v = V::decode(decoder)?;
map.insert(k, v); map.insert(k, v);
} }
Ok(map) Ok(map)

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

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

3
tests/issues.rs
View File

@ -5,3 +5,6 @@ mod issue_431;
#[path = "issues/issue_427.rs"] #[path = "issues/issue_427.rs"]
mod issue_427; 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 { impl bincode::Decode for Foo {
fn decode<D: bincode::de::Decoder>( fn decode<D: bincode::de::Decoder>(
mut decoder: D, decoder: &mut D,
) -> Result<Self, bincode::error::DecodeError> { ) -> Result<Self, bincode::error::DecodeError> {
Ok(Self { Ok(Self {
a: bincode::Decode::decode(&mut decoder)?, a: bincode::Decode::decode(decoder)?,
b: bincode::Decode::decode(&mut decoder)?, b: bincode::Decode::decode(decoder)?,
}) })
} }
} }