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")
.with_generic("E", ["bincode::enc::Encoder"])
.with_self_arg(FnSelfArg::RefSelf)
.with_arg("mut encoder", "E")
.with_arg("encoder", "&mut E")
.with_return_type("core::result::Result<(), bincode::error::EncodeError>")
.body(|fn_body| {
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
// {
// encoder.encode_u32(n)?;
// bincode::enc::Encode::encode(a, &mut encoder)?;
// bincode::enc::Encode::encode(b, &mut encoder)?;
// bincode::enc::Encode::encode(c, &mut encoder)?;
// bincode::enc::Encode::encode(a, encoder)?;
// bincode::enc::Encode::encode(b, encoder)?;
// bincode::enc::Encode::encode(c, encoder)?;
// }
match_body.group(Delimiter::Brace, |body| {
// variant index
@ -84,7 +84,7 @@ impl DeriveEnum {
Ok(())
})?;
args.punct(',');
args.push_parsed("&mut encoder")?;
args.push_parsed("encoder")?;
Ok(())
})?;
body.punct('?');
@ -93,12 +93,12 @@ impl DeriveEnum {
for field_name in variant.fields.names() {
if field_name.attributes().has_attribute(FieldAttribute::WithSerde)? {
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),
))?;
} else {
body.push_parsed(format!(
"bincode::enc::Encode::encode({}, &mut encoder)?;",
"bincode::enc::Encode::encode({}, encoder)?;",
field_name.to_string_with_prefix(TUPLE_FIELD_PREFIX),
))
?;

29
derive/src/derive_struct.rs
View File

@ -15,28 +15,31 @@ impl DeriveStruct {
.impl_for("bincode::enc::Encode")?
.modify_generic_constraints(|generics, where_constraints| {
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")
.with_generic("E", ["bincode::enc::Encoder"])
.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>")
.body(|fn_body| {
for field in fields.names() {
if field.attributes().has_attribute(FieldAttribute::WithSerde)? {
fn_body
.push_parsed(format!(
"bincode::Encode::encode(&bincode::serde::Compat(&self.{}), &mut encoder)?;",
field
))?;
if field
.attributes()
.has_attribute(FieldAttribute::WithSerde)?
{
fn_body.push_parsed(format!(
"bincode::Encode::encode(&bincode::serde::Compat(&self.{}), encoder)?;",
field
))?;
} else {
fn_body
.push_parsed(format!(
"bincode::enc::Encode::encode(&self.{}, &mut encoder)?;",
field
))?;
fn_body.push_parsed(format!(
"bincode::enc::Encode::encode(&self.{}, encoder)?;",
field
))?;
}
}
fn_body.push_parsed("Ok(())")?;

88
src/enc/impl_tuples.rs
View File

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

120
src/enc/impls.rs
View File

@ -18,37 +18,37 @@ use core::{
};
impl Encode for () {
fn encode<E: Encoder>(&self, _: E) -> Result<(), EncodeError> {
fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
Ok(())
}
}
impl<T> Encode for PhantomData<T> {
fn encode<E: Encoder>(&self, _: E) -> Result<(), EncodeError> {
fn encode<E: Encoder>(&self, _: &mut E) -> Result<(), EncodeError> {
Ok(())
}
}
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)
}
}
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])
}
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_u16(encoder.writer(), E::C::ENDIAN, *self)
@ -62,13 +62,13 @@ impl Encode for u16 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_u32(encoder.writer(), E::C::ENDIAN, *self)
@ -82,13 +82,13 @@ impl Encode for u32 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_u64(encoder.writer(), E::C::ENDIAN, *self)
@ -102,13 +102,13 @@ impl Encode for u64 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_u128(encoder.writer(), E::C::ENDIAN, *self)
@ -122,13 +122,13 @@ impl Encode for u128 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_usize(encoder.writer(), E::C::ENDIAN, *self)
@ -142,25 +142,25 @@ impl Encode for usize {
}
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)
}
}
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])
}
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_i16(encoder.writer(), E::C::ENDIAN, *self)
@ -174,13 +174,13 @@ impl Encode for i16 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_i32(encoder.writer(), E::C::ENDIAN, *self)
@ -194,13 +194,13 @@ impl Encode for i32 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_i64(encoder.writer(), E::C::ENDIAN, *self)
@ -214,13 +214,13 @@ impl Encode for i64 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_i128(encoder.writer(), E::C::ENDIAN, *self)
@ -234,13 +234,13 @@ impl Encode for i128 {
}
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)
}
}
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 {
IntEncoding::Variable => {
crate::varint::varint_encode_isize(encoder.writer(), E::C::ENDIAN, *self)
@ -254,13 +254,13 @@ impl Encode for isize {
}
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)
}
}
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 {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
@ -269,7 +269,7 @@ impl Encode for f32 {
}
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 {
Endian::Big => encoder.writer().write(&self.to_be_bytes()),
Endian::Little => encoder.writer().write(&self.to_le_bytes()),
@ -278,14 +278,14 @@ impl Encode for f64 {
}
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)
}
}
impl Encode for &'_ [u8] {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
super::encode_slice_len(&mut encoder, self.len())?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
super::encode_slice_len(encoder, self.len())?;
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
//
// 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)
// }
// }
//
// impl<T: Encode> Encode for &'_ [T] {
// fn encode<E: Encode>(&self, mut encoder: E) -> Result<(), EncodeError> {
// self.len().encode(&mut encoder)?;
// fn encode<E: Encode>(&self, encoder: &mut E) -> Result<(), EncodeError> {
// self.len().encode(encoder)?;
// for item in self.iter() {
// item.encode(&mut encoder)?;
// item.encode(encoder)?;
// }
// Ok(())
// }
// }
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)
}
}
@ -355,12 +355,12 @@ impl<T, const N: usize> Encode for [T; N]
where
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 {
super::encode_slice_len(&mut encoder, N)?;
super::encode_slice_len(encoder, N)?;
}
for item in self.iter() {
item.encode(&mut encoder)?;
item.encode(encoder)?;
}
Ok(())
}
@ -370,8 +370,8 @@ impl<T> Encode for Option<T>
where
T: Encode,
{
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
super::encode_option_variant(&mut encoder, self)?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
super::encode_option_variant(encoder, self)?;
if let Some(val) = self {
val.encode(encoder)?;
}
@ -384,14 +384,14 @@ where
T: 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 {
Ok(val) => {
0u8.encode(&mut encoder)?;
0u8.encode(encoder)?;
val.encode(encoder)
}
Err(err) => {
1u8.encode(&mut encoder)?;
1u8.encode(encoder)?;
err.encode(encoder)
}
}
@ -402,7 +402,7 @@ impl<T> Encode for Cell<T>
where
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)
}
}
@ -411,7 +411,7 @@ impl<T> Encode for RefCell<T>
where
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
.try_borrow()
.map_err(|e| EncodeError::RefCellAlreadyBorrowed {
@ -423,9 +423,9 @@ where
}
impl Encode for Duration {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
self.as_secs().encode(&mut encoder)?;
self.subsec_nanos().encode(&mut encoder)?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.as_secs().encode(encoder)?;
self.subsec_nanos().encode(encoder)?;
Ok(())
}
}
@ -434,9 +434,9 @@ impl<T> Encode for Range<T>
where
T: Encode,
{
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
self.start.encode(&mut encoder)?;
self.end.encode(&mut encoder)?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.start.encode(encoder)?;
self.end.encode(encoder)?;
Ok(())
}
}
@ -445,9 +445,9 @@ impl<T> Encode for RangeInclusive<T>
where
T: Encode,
{
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
self.start().encode(&mut encoder)?;
self.end().encode(&mut encoder)?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.start().encode(encoder)?;
self.end().encode(encoder)?;
Ok(())
}
}
@ -456,17 +456,17 @@ impl<T> Encode for Bound<T>
where
T: Encode,
{
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
match self {
Self::Unbounded => {
0u32.encode(encoder)?;
}
Self::Included(val) => {
1u32.encode(&mut encoder)?;
1u32.encode(encoder)?;
val.encode(encoder)?;
}
Self::Excluded(val) => {
2u32.encode(&mut encoder)?;
2u32.encode(encoder)?;
val.encode(encoder)?;
}
}
@ -478,7 +478,7 @@ impl<'a, T> Encode for &'a T
where
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)
}
}

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.
pub trait Encode {
/// 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.
@ -54,7 +54,7 @@ where
/// Encode the variant of the given option. Will not encode the option itself.
#[inline]
pub(crate) fn encode_option_variant<E: Encoder, T>(
encoder: E,
encoder: &mut E,
value: &Option<T>,
) -> Result<(), EncodeError> {
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
#[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)
}

55
src/features/atomic.rs
View File

@ -5,7 +5,10 @@ use core::sync::atomic::{
};
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)
}
}
@ -17,7 +20,10 @@ impl Decode for AtomicBool {
}
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)
}
}
@ -29,7 +35,10 @@ impl Decode for AtomicU8 {
}
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)
}
}
@ -41,7 +50,10 @@ impl Decode for AtomicU16 {
}
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)
}
}
@ -53,7 +65,10 @@ impl Decode for AtomicU32 {
}
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)
}
}
@ -65,7 +80,10 @@ impl Decode for AtomicU64 {
}
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)
}
}
@ -77,7 +95,10 @@ impl Decode for AtomicUsize {
}
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)
}
}
@ -89,7 +110,10 @@ impl Decode for AtomicI8 {
}
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)
}
}
@ -101,7 +125,10 @@ impl Decode for AtomicI16 {
}
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)
}
}
@ -113,7 +140,10 @@ impl Decode for AtomicI32 {
}
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)
}
}
@ -125,7 +155,10 @@ impl Decode for AtomicI64 {
}
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)
}
}

48
src/features/impl_alloc.rs
View File

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

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 {
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)
}
}
@ -121,7 +121,7 @@ impl<'de> BorrowDecode<'de> for &'de CStr {
}
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)
}
}
@ -144,7 +144,7 @@ impl<T> Encode for Mutex<T>
where
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 {
type_name: core::any::type_name::<Mutex<T>>(),
})?;
@ -166,7 +166,7 @@ impl<T> Encode for RwLock<T>
where
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 {
type_name: core::any::type_name::<RwLock<T>>(),
})?;
@ -185,7 +185,7 @@ where
}
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| {
EncodeError::InvalidSystemTime {
inner: e,
@ -207,7 +207,7 @@ impl Decode for SystemTime {
}
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() {
Some(str) => str.encode(encoder),
None => Err(EncodeError::InvalidPathCharacters),
@ -223,7 +223,7 @@ impl<'de> BorrowDecode<'de> for &'de Path {
}
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)
}
}
@ -236,14 +236,14 @@ impl Decode for PathBuf {
}
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 {
IpAddr::V4(v4) => {
0u32.encode(&mut encoder)?;
0u32.encode(encoder)?;
v4.encode(encoder)
}
IpAddr::V6(v6) => {
1u32.encode(&mut encoder)?;
1u32.encode(encoder)?;
v6.encode(encoder)
}
}
@ -265,7 +265,7 @@ impl Decode for IpAddr {
}
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)
}
}
@ -277,7 +277,7 @@ impl Decode for Ipv4Addr {
}
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)
}
}
@ -289,14 +289,14 @@ impl Decode for Ipv6Addr {
}
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 {
SocketAddr::V4(v4) => {
0u32.encode(&mut encoder)?;
0u32.encode(encoder)?;
v4.encode(encoder)
}
SocketAddr::V6(v6) => {
1u32.encode(&mut encoder)?;
1u32.encode(encoder)?;
v6.encode(encoder)
}
}
@ -318,8 +318,8 @@ impl Decode for SocketAddr {
}
impl Encode for SocketAddrV4 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
self.ip().encode(&mut encoder)?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.ip().encode(encoder)?;
self.port().encode(encoder)
}
}
@ -333,8 +333,8 @@ impl Decode for SocketAddrV4 {
}
impl Encode for SocketAddrV6 {
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
self.ip().encode(&mut encoder)?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
self.ip().encode(encoder)?;
self.port().encode(encoder)
}
}
@ -355,11 +355,11 @@ where
K: Encode,
V: Encode,
{
fn encode<E: Encoder>(&self, mut encoder: E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(&mut encoder, self.len())?;
fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError> {
crate::enc::encode_slice_len(encoder, self.len())?;
for (k, v) in self.iter() {
Encode::encode(k, &mut encoder)?;
Encode::encode(v, &mut encoder)?;
Encode::encode(k, encoder)?;
Encode::encode(v, encoder)?;
}
Ok(())
}

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

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

6
tests/alloc.rs
View File

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

3
tests/issues.rs
View File

@ -8,3 +8,6 @@ mod issue_427;
#[path = "issues/issue_467.rs"]
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;
#[derive(bincode::Decode)]
#[derive(bincode::Decode, bincode::Encode)]
struct AllTypes(BTreeMap<u8, AllTypes>);
#[test]

6
tests/std.rs
View File

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