From 1f6d717145e5ee26f172a7237567143b57509244 Mon Sep 17 00:00:00 2001 From: Victor Koenders Date: Wed, 19 Jan 2022 18:35:49 +0100 Subject: [PATCH] made the serde functions consistent with the base bincode functions --- src/features/impl_std.rs | 36 +++++++++++++++++++++++--------- src/features/serde/de_owned.rs | 29 +++++++++++++++++++++++++- src/features/serde/ser.rs | 38 ++++++++++++++++++++++++++++++++-- src/lib.rs | 4 ++-- tests/serde.rs | 8 +++---- 5 files changed, 96 insertions(+), 19 deletions(-) diff --git a/src/features/impl_std.rs b/src/features/impl_std.rs index d49f5c86..811148ef 100644 --- a/src/features/impl_std.rs +++ b/src/features/impl_std.rs @@ -23,17 +23,23 @@ use std::{ #[cfg_attr(docsrs, doc(cfg(feature = "std")))] pub fn decode_from_std_read( src: &mut R, - _config: C, + config: C, ) -> Result { - let reader = IoReader { reader: src }; - let mut decoder = DecoderImpl::<_, C>::new(reader, _config); + let reader = IoReader::new(src); + let mut decoder = DecoderImpl::<_, C>::new(reader, config); D::decode(&mut decoder) } -struct IoReader { +pub(crate) struct IoReader { reader: R, } +impl IoReader { + pub fn new(reader: R) -> Self { + Self { reader } + } +} + impl Reader for IoReader where R: std::io::Read, @@ -79,20 +85,30 @@ pub fn encode_into_std_write( dst: &mut W, config: C, ) -> Result { - let writer = IoWriter { - writer: dst, - bytes_written: 0, - }; + let writer = IoWriter::new(dst); let mut encoder = EncoderImpl::<_, C>::new(writer, config); val.encode(&mut encoder)?; - Ok(encoder.into_writer().bytes_written) + Ok(encoder.into_writer().bytes_written()) } -struct IoWriter<'a, W: std::io::Write> { +pub(crate) struct IoWriter<'a, W: std::io::Write> { writer: &'a mut W, bytes_written: usize, } +impl<'a, W: std::io::Write> IoWriter<'a, W> { + pub fn new(writer: &'a mut W) -> Self { + Self { + writer, + bytes_written: 0, + } + } + + pub fn bytes_written(&self) -> usize { + self.bytes_written + } +} + impl<'storage, W: std::io::Write> Writer for IoWriter<'storage, W> { #[inline(always)] fn write(&mut self, bytes: &[u8]) -> Result<(), EncodeError> { diff --git a/src/features/serde/de_owned.rs b/src/features/serde/de_owned.rs index 69880351..8516431a 100644 --- a/src/features/serde/de_owned.rs +++ b/src/features/serde/de_owned.rs @@ -1,7 +1,7 @@ use super::DecodeError as SerdeDecodeError; use crate::{ config::Config, - de::{Decode, Decoder}, + de::{read::Reader, Decode, Decoder}, error::DecodeError, }; use serde_incl::de::*; @@ -24,6 +24,33 @@ where Ok((result, bytes_read)) } +/// Decode an owned type from the given `std::io::Read`. +#[cfg(feature = "std")] +#[cfg_attr(docsrs, doc(cfg(feature = "std")))] +pub fn decode_from_std_read( + src: &mut R, + config: C, +) -> Result { + let reader = crate::IoReader::new(src); + let mut decoder = crate::de::DecoderImpl::new(reader, config); + let serde_decoder = SerdeDecoder { de: &mut decoder }; + D::deserialize(serde_decoder) +} + +/// Attempt to decode a given type `D` from the given [Reader]. +/// +/// See the [config] module for more information on configurations. +/// +/// [config]: config/index.html +pub fn decode_from_reader( + reader: R, + config: C, +) -> Result { + let mut decoder = crate::de::DecoderImpl::<_, C>::new(reader, config); + let serde_decoder = SerdeDecoder { de: &mut decoder }; + D::deserialize(serde_decoder) +} + pub(crate) struct SerdeDecoder<'a, DE: Decoder> { pub(crate) de: &'a mut DE, } diff --git a/src/features/serde/ser.rs b/src/features/serde/ser.rs index 6ff6b8b3..f57ad964 100644 --- a/src/features/serde/ser.rs +++ b/src/features/serde/ser.rs @@ -1,7 +1,7 @@ use super::EncodeError as SerdeEncodeError; use crate::{ config::Config, - enc::{Encode, Encoder}, + enc::{write::Writer, Encode, Encoder}, error::EncodeError, }; #[cfg(feature = "alloc")] @@ -23,7 +23,7 @@ where } /// Encode a `serde` `Serialize` type into a given byte slice with the bincode algorithm -pub fn encode_to_slice(t: T, slice: &mut [u8], config: C) -> Result +pub fn encode_into_slice(t: T, slice: &mut [u8], config: C) -> Result where T: Serialize, C: Config, @@ -35,6 +35,40 @@ where Ok(encoder.into_writer().bytes_written()) } +/// Encode the given value into a custom [Writer]. +/// +/// See the [config] module for more information on configurations. +/// +/// [config]: config/index.html +pub fn encode_into_writer( + val: E, + writer: W, + config: C, +) -> Result<(), EncodeError> { + let mut encoder = crate::enc::EncoderImpl::<_, C>::new(writer, config); + let serializer = SerdeEncoder { enc: &mut encoder }; + val.serialize(serializer)?; + Ok(()) +} + +/// Encode the given value into any type that implements `std::io::Write`, e.g. `std::fs::File`, with the given `Config`. +/// See the [config] module for more information. +/// +/// [config]: config/index.html +#[cfg_attr(docsrs, doc(cfg(feature = "std")))] +#[cfg(feature = "std")] +pub fn encode_into_std_write( + val: E, + dst: &mut W, + config: C, +) -> Result { + let writer = crate::IoWriter::new(dst); + let mut encoder = crate::enc::EncoderImpl::<_, C>::new(writer, config); + let serializer = SerdeEncoder { enc: &mut encoder }; + val.serialize(serializer)?; + Ok(encoder.into_writer().bytes_written()) +} + pub(super) struct SerdeEncoder<'a, ENC: Encoder> { pub(super) enc: &'a mut ENC, } diff --git a/src/lib.rs b/src/lib.rs index f6dd0094..f38c1620 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -133,9 +133,9 @@ pub fn decode_from_slice<'a, D: de::BorrowDecode<'a>, C: Config>( /// [config]: config/index.html pub fn decode_from_reader( reader: R, - _config: C, + config: C, ) -> Result { - let mut decoder = de::DecoderImpl::<_, C>::new(reader, _config); + let mut decoder = de::DecoderImpl::<_, C>::new(reader, config); D::decode(&mut decoder) } diff --git a/tests/serde.rs b/tests/serde.rs index 56413685..e9d3cffb 100644 --- a/tests/serde.rs +++ b/tests/serde.rs @@ -61,8 +61,8 @@ fn test_serialize_deserialize_borrowed_data() { ]; let mut result = [0u8; 20]; - let len = - bincode::serde::encode_to_slice(&input, &mut result, bincode::config::standard()).unwrap(); + let len = bincode::serde::encode_into_slice(&input, &mut result, bincode::config::standard()) + .unwrap(); let result = &result[..len]; assert_eq!(result, expected); @@ -107,8 +107,8 @@ fn test_serialize_deserialize_owned_data() { ]; let mut result = [0u8; 20]; - let len = - bincode::serde::encode_to_slice(&input, &mut result, bincode::config::standard()).unwrap(); + let len = bincode::serde::encode_into_slice(&input, &mut result, bincode::config::standard()) + .unwrap(); let result = &result[..len]; assert_eq!(result, expected);