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

Switch Encode to take &mut E (#471)

This commit is contained in:
Lena Hellström 2022-01-13 12:26:09 +01:00 committed by GitHub
parent 4149c0f29f
commit 8106eadf66
14 changed files with 251 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
derive/src/derive_enum.rs
View File

@ -29,7 +29,7 @@ impl DeriveEnum {
.generate_fn("encode") .generate_fn("encode")
.with_generic("E", ["bincode::enc::Encoder"]) .with_generic("E", ["bincode::enc::Encoder"])
.with_self_arg(FnSelfArg::RefSelf) .with_self_arg(FnSelfArg::RefSelf)
.with_arg("mut encoder", "E") .with_arg("encoder", "&mut E")
.with_return_type("core::result::Result<(), bincode::error::EncodeError>") .with_return_type("core::result::Result<(), bincode::error::EncodeError>")
.body(|fn_body| { .body(|fn_body| {
fn_body.ident_str("match"); fn_body.ident_str("match");
@ -70,9 +70,9 @@ impl DeriveEnum {
// Note that the fields are available as locals because of the match destructuring above // Note that the fields are available as locals because of the match destructuring above
// { // {
// encoder.encode_u32(n)?; // encoder.encode_u32(n)?;
// bincode::enc::Encode::encode(a, &mut encoder)?; // bincode::enc::Encode::encode(a, encoder)?;
// bincode::enc::Encode::encode(b, &mut encoder)?; // bincode::enc::Encode::encode(b, encoder)?;
// bincode::enc::Encode::encode(c, &mut encoder)?; // bincode::enc::Encode::encode(c, encoder)?;
// } // }
match_body.group(Delimiter::Brace, |body| { match_body.group(Delimiter::Brace, |body| {
// variant index // variant index
@ -84,7 +84,7 @@ impl DeriveEnum {
Ok(()) Ok(())
})?; })?;
args.punct(','); args.punct(',');
args.push_parsed("&mut encoder")?; args.push_parsed("encoder")?;
Ok(()) Ok(())
})?; })?;
body.punct('?'); body.punct('?');
@ -93,12 +93,12 @@ impl DeriveEnum {
for field_name in variant.fields.names() { for field_name in variant.fields.names() {
if field_name.attributes().has_attribute(FieldAttribute::WithSerde)? { if field_name.attributes().has_attribute(FieldAttribute::WithSerde)? {
body.push_parsed(format!( body.push_parsed(format!(
"bincode::enc::Encode::encode(&bincode::serde::Compat({}), &mut encoder)?;", "bincode::enc::Encode::encode(&bincode::serde::Compat({}), encoder)?;",
field_name.to_string_with_prefix(TUPLE_FIELD_PREFIX), field_name.to_string_with_prefix(TUPLE_FIELD_PREFIX),
))?; ))?;
} else { } else {
body.push_parsed(format!( body.push_parsed(format!(
"bincode::enc::Encode::encode({}, &mut encoder)?;", "bincode::enc::Encode::encode({}, encoder)?;",
field_name.to_string_with_prefix(TUPLE_FIELD_PREFIX), field_name.to_string_with_prefix(TUPLE_FIELD_PREFIX),
)) ))
?; ?;

21
derive/src/derive_struct.rs
View File

@ -15,26 +15,29 @@ impl DeriveStruct {
.impl_for("bincode::enc::Encode")? .impl_for("bincode::enc::Encode")?
.modify_generic_constraints(|generics, where_constraints| { .modify_generic_constraints(|generics, where_constraints| {
for g in generics.iter_generics() { for g in generics.iter_generics() {
where_constraints.push_constraint(g, "bincode::enc::Encode").unwrap(); where_constraints
.push_constraint(g, "bincode::enc::Encode")
.unwrap();
} }
}) })
.generate_fn("encode") .generate_fn("encode")
.with_generic("E", ["bincode::enc::Encoder"]) .with_generic("E", ["bincode::enc::Encoder"])
.with_self_arg(virtue::generate::FnSelfArg::RefSelf) .with_self_arg(virtue::generate::FnSelfArg::RefSelf)
.with_arg("mut encoder", "E") .with_arg("encoder", "&mut E")
.with_return_type("core::result::Result<(), bincode::error::EncodeError>") .with_return_type("core::result::Result<(), bincode::error::EncodeError>")
.body(|fn_body| { .body(|fn_body| {
for field in fields.names() { for field in fields.names() {
if field.attributes().has_attribute(FieldAttribute::WithSerde)? { if field
fn_body .attributes()
.push_parsed(format!( .has_attribute(FieldAttribute::WithSerde)?
"bincode::Encode::encode(&bincode::serde::Compat(&self.{}), &mut encoder)?;", {
fn_body.push_parsed(format!(
"bincode::Encode::encode(&bincode::serde::Compat(&self.{}), encoder)?;",
field field
))?; ))?;
} else { } else {
fn_body fn_body.push_parsed(format!(
.push_parsed(format!( "bincode::enc::Encode::encode(&self.{}, encoder)?;",
"bincode::enc::Encode::encode(&self.{}, &mut encoder)?;",
field field
))?; ))?;
} }

88
src/enc/impl_tuples.rs
View File

@ -5,8 +5,8 @@ impl<A> Encode for (A,)
where where
A: Encode, A: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -16,9 +16,9 @@ where
A: Encode, A: Encode,
B: Encode, B: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
self.1.encode(&mut encoder)?; self.1.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -29,10 +29,10 @@ where
B: Encode, B: Encode,
C: Encode, C: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
self.1.encode(&mut encoder)?; self.1.encode(encoder)?;
self.2.encode(&mut encoder)?; self.2.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -44,11 +44,11 @@ where
C: Encode, C: Encode,
D: Encode, D: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
self.1.encode(&mut encoder)?; self.1.encode(encoder)?;
self.2.encode(&mut encoder)?; self.2.encode(encoder)?;
self.3.encode(&mut encoder)?; self.3.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -61,12 +61,12 @@ where
D: Encode, D: Encode,
E: Encode, E: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
self.1.encode(&mut encoder)?; self.1.encode(encoder)?;
self.2.encode(&mut encoder)?; self.2.encode(encoder)?;
self.3.encode(&mut encoder)?; self.3.encode(encoder)?;
self.4.encode(&mut encoder)?; self.4.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -80,13 +80,13 @@ where
E: Encode, E: Encode,
F: Encode, F: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
self.1.encode(&mut encoder)?; self.1.encode(encoder)?;
self.2.encode(&mut encoder)?; self.2.encode(encoder)?;
self.3.encode(&mut encoder)?; self.3.encode(encoder)?;
self.4.encode(&mut encoder)?; self.4.encode(encoder)?;
self.5.encode(&mut encoder)?; self.5.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -101,14 +101,14 @@ where
F: Encode, F: Encode,
G: Encode, G: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
self.1.encode(&mut encoder)?; self.1.encode(encoder)?;
self.2.encode(&mut encoder)?; self.2.encode(encoder)?;
self.3.encode(&mut encoder)?; self.3.encode(encoder)?;
self.4.encode(&mut encoder)?; self.4.encode(encoder)?;
self.5.encode(&mut encoder)?; self.5.encode(encoder)?;
self.6.encode(&mut encoder)?; self.6.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -124,15 +124,15 @@ where
G: Encode, G: Encode,
H: Encode, H: Encode,
{ {
fn encode<_E: Encoder>(&self, mut encoder: _E) -> Result<(), EncodeError> { fn encode<_E: Encoder>(&self, encoder: &mut _E) -> Result<(), EncodeError> {
self.0.encode(&mut encoder)?; self.0.encode(encoder)?;
self.1.encode(&mut encoder)?; self.1.encode(encoder)?;
self.2.encode(&mut encoder)?; self.2.encode(encoder)?;
self.3.encode(&mut encoder)?; self.3.encode(encoder)?;
self.4.encode(&mut encoder)?; self.4.encode(encoder)?;
self.5.encode(&mut encoder)?; self.5.encode(encoder)?;
self.6.encode(&mut encoder)?; self.6.encode(encoder)?;
self.7.encode(&mut encoder)?; self.7.encode(encoder)?;
Ok(()) Ok(())
} }
} }

120
src/enc/impls.rs
View File

@ -18,37 +18,37 @@ use core::{
}; };
impl Encode for () { impl Encode for () {
fn encode<E: Encoder>(&self, _: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
Ok(()) Ok(())
} }
} }
impl<T> Encode for PhantomData<T> { impl<T> Encode for PhantomData<T> {
fn encode<E: Encoder>(&self, _: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
Ok(()) Ok(())
} }
} }
impl Encode for bool { impl Encode for bool {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
if *self { 1u8 } else { 0u8 }.encode(encoder) if *self { 1u8 } else { 0u8 }.encode(encoder)
} }
} }
impl Encode for u8 { impl Encode for u8 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
encoder.writer().write(&[*self]) encoder.writer().write(&[*self])
} }
} }
impl Encode for NonZeroU8 { impl Encode for NonZeroU8 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for u16 { impl Encode for u16 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self)
@ -62,13 +62,13 @@ impl Encode for u16 {
} }
impl Encode for NonZeroU16 { impl Encode for NonZeroU16 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for u32 { impl Encode for u32 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self)
@ -82,13 +82,13 @@ impl Encode for u32 {
} }
impl Encode for NonZeroU32 { impl Encode for NonZeroU32 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for u64 { impl Encode for u64 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self)
@ -102,13 +102,13 @@ impl Encode for u64 {
} }
impl Encode for NonZeroU64 { impl Encode for NonZeroU64 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for u128 { impl Encode for u128 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self)
@ -122,13 +122,13 @@ impl Encode for u128 {
} }
impl Encode for NonZeroU128 { impl Encode for NonZeroU128 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for usize { impl Encode for usize {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self)
@ -142,25 +142,25 @@ impl Encode for usize {
} }
impl Encode for NonZeroUsize { impl Encode for NonZeroUsize {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for i8 { impl Encode for i8 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
encoder.writer().write(&[*self as u8]) encoder.writer().write(&[*self as u8])
} }
} }
impl Encode for NonZeroI8 { impl Encode for NonZeroI8 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for i16 { impl Encode for i16 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self)
@ -174,13 +174,13 @@ impl Encode for i16 {
} }
impl Encode for NonZeroI16 { impl Encode for NonZeroI16 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for i32 { impl Encode for i32 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self)
@ -194,13 +194,13 @@ impl Encode for i32 {
} }
impl Encode for NonZeroI32 { impl Encode for NonZeroI32 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for i64 { impl Encode for i64 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self)
@ -214,13 +214,13 @@ impl Encode for i64 {
} }
impl Encode for NonZeroI64 { impl Encode for NonZeroI64 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for i128 { impl Encode for i128 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self)
@ -234,13 +234,13 @@ impl Encode for i128 {
} }
impl Encode for NonZeroI128 { impl Encode for NonZeroI128 {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for isize { impl Encode for isize {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::INT_ENCODING { match E::C::INT_ENCODING {
IntEncoding::Variable => { IntEncoding::Variable => {
crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self) crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self)
@ -254,13 +254,13 @@ impl Encode for isize {
} }
impl Encode for NonZeroIsize { impl Encode for NonZeroIsize {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.get().encode(encoder) self.get().encode(encoder)
} }
} }
impl Encode for f32 { impl Encode for f32 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::ENDIAN { match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endian::Little => encoder.writer().write(&self.to_le_bytes()),
@ -269,7 +269,7 @@ impl Encode for f32 {
} }
impl Encode for f64 { impl Encode for f64 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match E::C::ENDIAN { match E::C::ENDIAN {
Endian::Big => encoder.writer().write(&self.to_be_bytes()), Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()), Endian::Little => encoder.writer().write(&self.to_le_bytes()),
@ -278,14 +278,14 @@ impl Encode for f64 {
} }
impl Encode for char { impl Encode for char {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
encode_utf8(encoder.writer(), *self) encode_utf8(encoder.writer(), *self)
} }
} }
impl Encode for &'_ [u8] { impl Encode for &'_ [u8] {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
super::encode_slice_len(&mut encoder, self.len())?; super::encode_slice_len(encoder, self.len())?;
encoder.writer().write(self) encoder.writer().write(self)
} }
} }
@ -330,23 +330,23 @@ fn encode_utf8(writer: &mut impl Writer, c: char) -> Result<(), EncodeError> {
// but those implementations overlap because u8 also implements Encodeabl // but those implementations overlap because u8 also implements Encodeabl
// //
// default impl Encode for &'_ [u8] { // default impl Encode for &'_ [u8] {
// fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> { // fn encode<E: Encode>(&self, encoder: &mut E) -> Result<(), EncodeError> {
// encoder.encode_slice(*self) // encoder.encode_slice(*self)
// } // }
// } // }
// //
// impl<T: Encode> Encode for &'_ [T] { // impl<T: Encode> Encode for &'_ [T] {
// fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> { // fn encode<E: Encode>(&self, encoder: &mut E) -> Result<(), EncodeError> {
// self.len().encode(&mut encoder)?; // self.len().encode(encoder)?;
// for item in self.iter() { // for item in self.iter() {
// item.encode(&mut encoder)?; // item.encode(encoder)?;
// } // }
// Ok(()) // Ok(())
// } // }
// } // }
impl Encode for &'_ str { impl Encode for &'_ str {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.as_bytes().encode(encoder) self.as_bytes().encode(encoder)
} }
} }
@ -355,12 +355,12 @@ impl<T, const N: usize> Encode for [T; N]
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
if !E::C::SKIP_FIXED_ARRAY_LENGTH { if !E::C::SKIP_FIXED_ARRAY_LENGTH {
super::encode_slice_len(&mut encoder, N)?; super::encode_slice_len(encoder, N)?;
} }
for item in self.iter() { for item in self.iter() {
item.encode(&mut encoder)?; item.encode(encoder)?;
} }
Ok(()) Ok(())
} }
@ -370,8 +370,8 @@ impl<T> Encode for Option<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
super::encode_option_variant(&mut encoder, self)?; super::encode_option_variant(encoder, self)?;
if let Some(val) = self { if let Some(val) = self {
val.encode(encoder)?; val.encode(encoder)?;
} }
@ -384,14 +384,14 @@ where
T: Encode, T: Encode,
U: Encode, U: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match self { match self {
Ok(val) => { Ok(val) => {
0u8.encode(&mut encoder)?; 0u8.encode(encoder)?;
val.encode(encoder) val.encode(encoder)
} }
Err(err) => { Err(err) => {
1u8.encode(&mut encoder)?; 1u8.encode(encoder)?;
err.encode(encoder) err.encode(encoder)
} }
} }
@ -402,7 +402,7 @@ impl<T> Encode for Cell<T>
where where
T: Encode + Copy, T: Encode + Copy,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
T::encode(&self.get(), encoder) T::encode(&self.get(), encoder)
} }
} }
@ -411,7 +411,7 @@ impl<T> Encode for RefCell<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
let borrow_guard = self let borrow_guard = self
.try_borrow() .try_borrow()
.map_err(|e| EncodeError::RefCellAlreadyBorrowed { .map_err(|e| EncodeError::RefCellAlreadyBorrowed {
@ -423,9 +423,9 @@ where
} }
impl Encode for Duration { impl Encode for Duration {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.as_secs().encode(&mut encoder)?; self.as_secs().encode(encoder)?;
self.subsec_nanos().encode(&mut encoder)?; self.subsec_nanos().encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -434,9 +434,9 @@ impl<T> Encode for Range<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.start.encode(&mut encoder)?; self.start.encode(encoder)?;
self.end.encode(&mut encoder)?; self.end.encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -445,9 +445,9 @@ impl<T> Encode for RangeInclusive<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.start().encode(&mut encoder)?; self.start().encode(encoder)?;
self.end().encode(&mut encoder)?; self.end().encode(encoder)?;
Ok(()) Ok(())
} }
} }
@ -456,17 +456,17 @@ impl<T> Encode for Bound<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match self { match self {
Self::Unbounded => { Self::Unbounded => {
0u32.encode(encoder)?; 0u32.encode(encoder)?;
} }
Self::Included(val) => { Self::Included(val) => {
1u32.encode(&mut encoder)?; 1u32.encode(encoder)?;
val.encode(encoder)?; val.encode(encoder)?;
} }
Self::Excluded(val) => { Self::Excluded(val) => {
2u32.encode(&mut encoder)?; 2u32.encode(encoder)?;
val.encode(encoder)?; val.encode(encoder)?;
} }
} }
@ -478,7 +478,7 @@ impl<'a, T> Encode for &'a T
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
T::encode(self, encoder) T::encode(self, encoder)
} }
} }

6
src/enc/mod.rs
View File

@ -16,7 +16,7 @@ pub use self::encoder::EncoderImpl;
/// This trait will be automatically implemented if you enable the `derive` feature and add `#[derive(bincode::Encode)]` to your trait. /// This trait will be automatically implemented if you enable the `derive` feature and add `#[derive(bincode::Encode)]` to your trait.
pub trait Encode { pub trait Encode {
/// Encode a given type. /// Encode a given type.
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError>; fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError>;
} }
/// Helper trait to encode basic types into. /// Helper trait to encode basic types into.
@ -54,7 +54,7 @@ where
/// Encode the variant of the given option. Will not encode the option itself. /// Encode the variant of the given option. Will not encode the option itself.
#[inline] #[inline]
pub(crate) fn encode_option_variant<E: Encoder, T>( pub(crate) fn encode_option_variant<E: Encoder, T>(
encoder: E, encoder: &mut E,
value: &Option<T>, value: &Option<T>,
) -> Result<(), EncodeError> { ) -> Result<(), EncodeError> {
match value { match value {
@ -65,6 +65,6 @@ pub(crate) fn encode_option_variant<E: Encoder, T>(
/// Encodes the length of any slice, container, etc into the given encoder /// Encodes the length of any slice, container, etc into the given encoder
#[inline] #[inline]
pub(crate) fn encode_slice_len<E: Encoder>(encoder: E, len: usize) -> Result<(), EncodeError> { pub(crate) fn encode_slice_len<E: Encoder>(encoder: &mut E, len: usize) -> Result<(), EncodeError> {
(len as u64).encode(encoder) (len as u64).encode(encoder)
} }

55
src/features/atomic.rs
View File

@ -5,7 +5,10 @@ use core::sync::atomic::{
}; };
impl Encode for AtomicBool { impl Encode for AtomicBool {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -17,7 +20,10 @@ impl Decode for AtomicBool {
} }
impl Encode for AtomicU8 { impl Encode for AtomicU8 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -29,7 +35,10 @@ impl Decode for AtomicU8 {
} }
impl Encode for AtomicU16 { impl Encode for AtomicU16 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -41,7 +50,10 @@ impl Decode for AtomicU16 {
} }
impl Encode for AtomicU32 { impl Encode for AtomicU32 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -53,7 +65,10 @@ impl Decode for AtomicU32 {
} }
impl Encode for AtomicU64 { impl Encode for AtomicU64 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -65,7 +80,10 @@ impl Decode for AtomicU64 {
} }
impl Encode for AtomicUsize { impl Encode for AtomicUsize {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -77,7 +95,10 @@ impl Decode for AtomicUsize {
} }
impl Encode for AtomicI8 { impl Encode for AtomicI8 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -89,7 +110,10 @@ impl Decode for AtomicI8 {
} }
impl Encode for AtomicI16 { impl Encode for AtomicI16 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -101,7 +125,10 @@ impl Decode for AtomicI16 {
} }
impl Encode for AtomicI32 { impl Encode for AtomicI32 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -113,7 +140,10 @@ impl Decode for AtomicI32 {
} }
impl Encode for AtomicI64 { impl Encode for AtomicI64 {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }
@ -125,7 +155,10 @@ impl Decode for AtomicI64 {
} }
impl Encode for AtomicIsize { impl Encode for AtomicIsize {
fn encode<E: crate::enc::Encoder>(&self, encoder: E) -> Result<(), crate::error::EncodeError> { fn encode<E: crate::enc::Encoder>(
&self,
encoder: &mut E,
) -> Result<(), crate::error::EncodeError> {
self.load(Ordering::SeqCst).encode(encoder) self.load(Ordering::SeqCst).encode(encoder)
} }
} }

48
src/features/impl_alloc.rs
View File

@ -70,10 +70,10 @@ impl<T> Encode for BinaryHeap<T>
where where
T: Encode + Ord, T: Encode + Ord,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?; crate::enc::encode_slice_len(encoder, self.len())?;
for val in self.iter() { for val in self.iter() {
val.encode(&mut encoder)?; val.encode(encoder)?;
} }
Ok(()) Ok(())
} }
@ -106,11 +106,11 @@ where
K: Encode + Ord, K: Encode + Ord,
V: Encode, V: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?; crate::enc::encode_slice_len(encoder, self.len())?;
for (key, val) in self.iter() { for (key, val) in self.iter() {
key.encode(&mut encoder)?; key.encode(encoder)?;
val.encode(&mut encoder)?; val.encode(encoder)?;
} }
Ok(()) Ok(())
} }
@ -140,10 +140,10 @@ impl<T> Encode for BTreeSet<T>
where where
T: Encode + Ord, T: Encode + Ord,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?; crate::enc::encode_slice_len(encoder, self.len())?;
for item in self.iter() { for item in self.iter() {
item.encode(&mut encoder)?; item.encode(encoder)?;
} }
Ok(()) Ok(())
} }
@ -173,10 +173,10 @@ impl<T> Encode for VecDeque<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?; crate::enc::encode_slice_len(encoder, self.len())?;
for item in self.iter() { for item in self.iter() {
item.encode(&mut encoder)?; item.encode(encoder)?;
} }
Ok(()) Ok(())
} }
@ -205,10 +205,10 @@ impl<T> Encode for Vec<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?; crate::enc::encode_slice_len(encoder, self.len())?;
for item in self.iter() { for item in self.iter() {
item.encode(&mut encoder)?; item.encode(encoder)?;
} }
Ok(()) Ok(())
} }
@ -222,7 +222,7 @@ impl Decode for String {
} }
impl Encode for String { impl Encode for String {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.as_bytes().encode(encoder) self.as_bytes().encode(encoder)
} }
} }
@ -241,7 +241,7 @@ impl<T> Encode for Box<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
T::encode(self, encoder) T::encode(self, encoder)
} }
} }
@ -260,10 +260,10 @@ impl<T> Encode for Box<[T]>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?; crate::enc::encode_slice_len(encoder, self.len())?;
for item in self.iter() { for item in self.iter() {
item.encode(&mut encoder)?; item.encode(encoder)?;
} }
Ok(()) Ok(())
} }
@ -298,7 +298,7 @@ impl<'cow, T> Encode for Cow<'cow, T>
where where
T: Encode + Clone, T: Encode + Clone,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.as_ref().encode(encoder) self.as_ref().encode(encoder)
} }
} }
@ -317,7 +317,7 @@ impl<T> Encode for Rc<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
T::encode(self, encoder) T::encode(self, encoder)
} }
} }
@ -338,7 +338,7 @@ impl<T> Encode for Arc<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
T::encode(self, encoder) T::encode(self, encoder)
} }
} }

46
src/features/impl_std.rs
View File

@ -108,7 +108,7 @@ impl<'storage, W: std::io::Write> Writer for IoWriter<'storage, W> {
} }
impl<'a> Encode for &'a CStr { impl<'a> Encode for &'a CStr {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.to_bytes_with_nul().encode(encoder) self.to_bytes_with_nul().encode(encoder)
} }
} }
@ -121,7 +121,7 @@ impl<'de> BorrowDecode<'de> for &'de CStr {
} }
impl Encode for CString { impl Encode for CString {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.as_bytes_with_nul().encode(encoder) self.as_bytes_with_nul().encode(encoder)
} }
} }
@ -144,7 +144,7 @@ impl<T> Encode for Mutex<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
let t = self.lock().map_err(|_| EncodeError::LockFailed { let t = self.lock().map_err(|_| EncodeError::LockFailed {
type_name: core::any::type_name::<Mutex<T>>(), type_name: core::any::type_name::<Mutex<T>>(),
})?; })?;
@ -166,7 +166,7 @@ impl<T> Encode for RwLock<T>
where where
T: Encode, T: Encode,
{ {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
let t = self.read().map_err(|_| EncodeError::LockFailed { let t = self.read().map_err(|_| EncodeError::LockFailed {
type_name: core::any::type_name::<RwLock<T>>(), type_name: core::any::type_name::<RwLock<T>>(),
})?; })?;
@ -185,7 +185,7 @@ where
} }
impl Encode for SystemTime { impl Encode for SystemTime {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
let duration = self.duration_since(SystemTime::UNIX_EPOCH).map_err(|e| { let duration = self.duration_since(SystemTime::UNIX_EPOCH).map_err(|e| {
EncodeError::InvalidSystemTime { EncodeError::InvalidSystemTime {
inner: e, inner: e,
@ -207,7 +207,7 @@ impl Decode for SystemTime {
} }
impl Encode for &'_ Path { impl Encode for &'_ Path {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match self.to_str() { match self.to_str() {
Some(str) => str.encode(encoder), Some(str) => str.encode(encoder),
None => Err(EncodeError::InvalidPathCharacters), None => Err(EncodeError::InvalidPathCharacters),
@ -223,7 +223,7 @@ impl<'de> BorrowDecode<'de> for &'de Path {
} }
impl Encode for PathBuf { impl Encode for PathBuf {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.as_path().encode(encoder) self.as_path().encode(encoder)
} }
} }
@ -236,14 +236,14 @@ impl Decode for PathBuf {
} }
impl Encode for IpAddr { impl Encode for IpAddr {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match self { match self {
IpAddr::V4(v4) => { IpAddr::V4(v4) => {
0u32.encode(&mut encoder)?; 0u32.encode(encoder)?;
v4.encode(encoder) v4.encode(encoder)
} }
IpAddr::V6(v6) => { IpAddr::V6(v6) => {
1u32.encode(&mut encoder)?; 1u32.encode(encoder)?;
v6.encode(encoder) v6.encode(encoder)
} }
} }
@ -265,7 +265,7 @@ impl Decode for IpAddr {
} }
impl Encode for Ipv4Addr { impl Encode for Ipv4Addr {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.octets().encode(encoder) self.octets().encode(encoder)
} }
} }
@ -277,7 +277,7 @@ impl Decode for Ipv4Addr {
} }
impl Encode for Ipv6Addr { impl Encode for Ipv6Addr {
fn encode<E: Encoder>(&self, encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.octets().encode(encoder) self.octets().encode(encoder)
} }
} }
@ -289,14 +289,14 @@ impl Decode for Ipv6Addr {
} }
impl Encode for SocketAddr { impl Encode for SocketAddr {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match self { match self {
SocketAddr::V4(v4) => { SocketAddr::V4(v4) => {
0u32.encode(&mut encoder)?; 0u32.encode(encoder)?;
v4.encode(encoder) v4.encode(encoder)
} }
SocketAddr::V6(v6) => { SocketAddr::V6(v6) => {
1u32.encode(&mut encoder)?; 1u32.encode(encoder)?;
v6.encode(encoder) v6.encode(encoder)
} }
} }
@ -318,8 +318,8 @@ impl Decode for SocketAddr {
} }
impl Encode for SocketAddrV4 { impl Encode for SocketAddrV4 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.ip().encode(&mut encoder)?; self.ip().encode(encoder)?;
self.port().encode(encoder) self.port().encode(encoder)
} }
} }
@ -333,8 +333,8 @@ impl Decode for SocketAddrV4 {
} }
impl Encode for SocketAddrV6 { impl Encode for SocketAddrV6 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.ip().encode(&mut encoder)?; self.ip().encode(encoder)?;
self.port().encode(encoder) self.port().encode(encoder)
} }
} }
@ -355,11 +355,11 @@ where
K: Encode, K: Encode,
V: Encode, V: Encode,
{ {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> { fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?; crate::enc::encode_slice_len(encoder, self.len())?;
for (k, v) in self.iter() { for (k, v) in self.iter() {
Encode::encode(k, &mut encoder)?; Encode::encode(k, encoder)?;
Encode::encode(v, &mut encoder)?; Encode::encode(v, encoder)?;
} }
Ok(()) Ok(())
} }

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

@ -113,9 +113,9 @@ where
{ {
fn encode<E: crate::enc::Encoder>( fn encode<E: crate::enc::Encoder>(
&self, &self,
mut encoder: E, encoder: &mut E,
) -> Result<(), crate::error::EncodeError> { ) -> Result<(), crate::error::EncodeError> {
let serializer = ser::SerdeEncoder { enc: &mut encoder }; let serializer = ser::SerdeEncoder { enc: encoder };
self.0.serialize(serializer)?; self.0.serialize(serializer)?;
Ok(()) Ok(())
} }
@ -150,9 +150,9 @@ where
{ {
fn encode<E: crate::enc::Encoder>( fn encode<E: crate::enc::Encoder>(
&self, &self,
mut encoder: E, encoder: &mut E,
) -> Result<(), crate::error::EncodeError> { ) -> Result<(), crate::error::EncodeError> {
let serializer = ser::SerdeEncoder { enc: &mut encoder }; let serializer = ser::SerdeEncoder { enc: encoder };
self.0.serialize(serializer)?; self.0.serialize(serializer)?;
Ok(()) Ok(())
} }

6
tests/alloc.rs
View File

@ -20,10 +20,10 @@ struct Foo {
impl bincode::enc::Encode for Foo { impl bincode::enc::Encode for Foo {
fn encode<E: bincode::enc::Encoder>( fn encode<E: bincode::enc::Encoder>(
&self, &self,
mut encoder: E, encoder: &mut E,
) -> Result<(), bincode::error::EncodeError> { ) -> Result<(), bincode::error::EncodeError> {
self.a.encode(&mut encoder)?; self.a.encode(encoder)?;
self.b.encode(&mut encoder)?; self.b.encode(encoder)?;
Ok(()) Ok(())
} }
} }

3
tests/issues.rs
View File

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

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

@ -0,0 +1,16 @@
#![cfg(all(feature = "std", feature = "derive"))]
extern crate std;
use std::collections::BTreeMap;
#[derive(bincode::Encode)]
struct AllTypes(BTreeMap<u8, AllTypes>);
#[test]
fn test_issue_459() {
let _result = bincode::encode_to_vec(
AllTypes(BTreeMap::new()),
bincode::config::Configuration::standard(),
);
}

2
tests/issues/issue_467.rs
View File

@ -4,7 +4,7 @@ extern crate std;
use std::collections::BTreeMap; use std::collections::BTreeMap;
#[derive(bincode::Decode)] #[derive(bincode::Decode, bincode::Encode)]
struct AllTypes(BTreeMap<u8, AllTypes>); struct AllTypes(BTreeMap<u8, AllTypes>);
#[test] #[test]

6
tests/std.rs
View File

@ -22,10 +22,10 @@ struct Foo {
impl bincode::enc::Encode for Foo { impl bincode::enc::Encode for Foo {
fn encode<E: bincode::enc::Encoder>( fn encode<E: bincode::enc::Encoder>(
&self, &self,
mut encoder: E, encoder: &mut E,
) -> Result<(), bincode::error::EncodeError> { ) -> Result<(), bincode::error::EncodeError> {
self.a.encode(&mut encoder)?; self.a.encode(encoder)?;
self.b.encode(&mut encoder)?; self.b.encode(encoder)?;
Ok(()) Ok(())
} }
} }