From 79c6b34957c952f092b6f3cbbac4bbe74533fd4c Mon Sep 17 00:00:00 2001 From: Dustin Hacker Date: Tue, 11 Aug 2026 02:53:37 +0000 Subject: [PATCH 1/3] Remove bincode dependency and update cargo outdated command --- .github/workflows/ci.yml | 2 +- Cargo.toml | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2531562..d53b0de 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -78,4 +78,4 @@ jobs: - uses: actions/checkout@v7 - uses: dtolnay/rust-toolchain@stable - uses: dtolnay/install@cargo-outdated - - run: cargo outdated --workspace --ignore bincode --exit-code 1 + - run: cargo outdated --workspace --exit-code 1 diff --git a/Cargo.toml b/Cargo.toml index 6f66ca5..6ee3d95 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,7 +23,6 @@ serde_core = { version = "1.0.220", default-features = false } serde = { version = "1.0.220", default-features = false } [dev-dependencies] -bincode = { version = "2", features = ["serde"] } serde = "1.0.220" serde_derive = "1.0.220" serde_test = "1.0.166" From beacb9b99a7b0fe70131d69170ed84f16fd7c4b1 Mon Sep 17 00:00:00 2001 From: Dustin Hacker Date: Tue, 11 Aug 2026 02:59:22 +0000 Subject: [PATCH 2/3] Refactor serialization examples to use updated container structures and remove unused code --- src/bytearray.rs | 28 +++++++++++++++------------- src/bytebuf.rs | 28 +++++++++++++++------------- src/bytes.rs | 19 ++++++++----------- 3 files changed, 38 insertions(+), 37 deletions(-) diff --git a/src/bytearray.rs b/src/bytearray.rs index da3bd43..4282a2c 100644 --- a/src/bytearray.rs +++ b/src/bytearray.rs @@ -13,26 +13,28 @@ use serde::ser::{Serialize, Serializer}; /// /// ``` /// use std::collections::HashMap; -/// use std::io; /// +/// use serde::{Deserialize, Serialize}; /// use serde_bytes::ByteArray; /// -/// fn deserialize_bytearrays() -> Result<(), bincode::error::DecodeError> { -/// let example_data = [2, 2, 3, 116, 119, 111, 1, 3, 111, 110, 101]; +/// #[derive(Debug, Serialize, Deserialize)] +/// struct Container { +/// payloads: HashMap>, +/// } /// -/// let map: HashMap>; -/// (map, _) = bincode::serde::decode_from_slice( -/// &example_data, -/// bincode::config::standard(), -/// )?; +/// fn build_container() -> Container { +/// let mut payloads = HashMap::new(); +/// payloads.insert(1, ByteArray::new(*b"one")); +/// payloads.insert(2, ByteArray::new(*b"two")); +/// Container { payloads } +/// } /// -/// println!("{:?}", map); +/// // ByteArray participates in Serde serialization/deserialization. +/// fn accepts_serde_data Deserialize<'de>>(_value: &T) {} /// -/// Ok(()) -/// } -/// # /// # fn main() { -/// # deserialize_bytearrays().unwrap(); +/// let container = build_container(); +/// accepts_serde_data(&container); /// # } /// ``` #[derive(Copy, Clone, Eq, Ord)] diff --git a/src/bytebuf.rs b/src/bytebuf.rs index 81fcda5..c35c966 100644 --- a/src/bytebuf.rs +++ b/src/bytebuf.rs @@ -20,26 +20,28 @@ use crate::Bytes; /// /// ``` /// use std::collections::HashMap; -/// use std::io; /// +/// use serde::{Deserialize, Serialize}; /// use serde_bytes::ByteBuf; /// -/// fn deserialize_bytebufs() -> Result<(), bincode::error::DecodeError> { -/// let example_data = [2, 2, 3, 116, 119, 111, 1, 3, 111, 110, 101]; +/// #[derive(Debug, Serialize, Deserialize)] +/// struct Container { +/// payloads: HashMap, +/// } /// -/// let map: HashMap; -/// (map, _) = bincode::serde::decode_from_slice( -/// &example_data, -/// bincode::config::standard(), -/// )?; +/// fn build_container() -> Container { +/// let mut payloads = HashMap::new(); +/// payloads.insert(1, ByteBuf::from(vec![111, 110, 101])); +/// payloads.insert(2, ByteBuf::from(vec![116, 119, 111])); +/// Container { payloads } +/// } /// -/// println!("{:?}", map); +/// // Works with any Serde-powered format selected by downstream code. +/// fn accepts_serde_data Deserialize<'de>>(_value: &T) {} /// -/// Ok(()) -/// } -/// # /// # fn main() { -/// # deserialize_bytebufs().unwrap(); +/// let container = build_container(); +/// accepts_serde_data(&container); /// # } /// ``` #[derive(Clone, Default, Eq, Ord)] diff --git a/src/bytes.rs b/src/bytes.rs index 754b4b9..3acd9de 100644 --- a/src/bytes.rs +++ b/src/bytes.rs @@ -19,27 +19,24 @@ use serde::ser::{Serialize, Serializer}; /// /// ``` /// use std::collections::HashMap; -/// use std::io; /// +/// use serde::Serialize; /// use serde_bytes::Bytes; /// -/// fn print_encoded_cache() -> Result<(), bincode::error::EncodeError> { +/// fn prepare_cache() -> HashMap { /// let mut cache = HashMap::new(); /// cache.insert(3, Bytes::new(b"three")); /// cache.insert(2, Bytes::new(b"two")); /// cache.insert(1, Bytes::new(b"one")); +/// cache +/// } /// -/// bincode::serde::encode_into_std_write( -/// &cache, -/// &mut io::stdout(), -/// bincode::config::standard(), -/// )?; +/// // The map can be serialized by any Serde serializer chosen by the caller. +/// fn accepts_any_serializer(_value: &T) {} /// -/// Ok(()) -/// } -/// # /// # fn main() { -/// # print_encoded_cache().unwrap(); +/// let cache = prepare_cache(); +/// accepts_any_serializer(&cache); /// # } /// ``` #[derive(Eq, Ord)] From dfe804c0d69fcddcc0d7109a5b9c6f0eefbc07dd Mon Sep 17 00:00:00 2001 From: Dustin Hacker Date: Tue, 11 Aug 2026 03:37:01 +0000 Subject: [PATCH 3/3] Refactor serialization examples to eliminate container struct and directly return payloads --- src/bytearray.rs | 13 ++++--------- src/bytebuf.rs | 13 ++++--------- 2 files changed, 8 insertions(+), 18 deletions(-) diff --git a/src/bytearray.rs b/src/bytearray.rs index 4282a2c..7794394 100644 --- a/src/bytearray.rs +++ b/src/bytearray.rs @@ -17,24 +17,19 @@ use serde::ser::{Serialize, Serializer}; /// use serde::{Deserialize, Serialize}; /// use serde_bytes::ByteArray; /// -/// #[derive(Debug, Serialize, Deserialize)] -/// struct Container { -/// payloads: HashMap>, -/// } -/// -/// fn build_container() -> Container { +/// fn build_payloads() -> HashMap> { /// let mut payloads = HashMap::new(); /// payloads.insert(1, ByteArray::new(*b"one")); /// payloads.insert(2, ByteArray::new(*b"two")); -/// Container { payloads } +/// payloads /// } /// /// // ByteArray participates in Serde serialization/deserialization. /// fn accepts_serde_data Deserialize<'de>>(_value: &T) {} /// /// # fn main() { -/// let container = build_container(); -/// accepts_serde_data(&container); +/// let payloads = build_payloads(); +/// accepts_serde_data(&payloads); /// # } /// ``` #[derive(Copy, Clone, Eq, Ord)] diff --git a/src/bytebuf.rs b/src/bytebuf.rs index c35c966..4bd757f 100644 --- a/src/bytebuf.rs +++ b/src/bytebuf.rs @@ -24,24 +24,19 @@ use crate::Bytes; /// use serde::{Deserialize, Serialize}; /// use serde_bytes::ByteBuf; /// -/// #[derive(Debug, Serialize, Deserialize)] -/// struct Container { -/// payloads: HashMap, -/// } -/// -/// fn build_container() -> Container { +/// fn build_payloads() -> HashMap { /// let mut payloads = HashMap::new(); /// payloads.insert(1, ByteBuf::from(vec![111, 110, 101])); /// payloads.insert(2, ByteBuf::from(vec![116, 119, 111])); -/// Container { payloads } +/// payloads /// } /// /// // Works with any Serde-powered format selected by downstream code. /// fn accepts_serde_data Deserialize<'de>>(_value: &T) {} /// /// # fn main() { -/// let container = build_container(); -/// accepts_serde_data(&container); +/// let payloads = build_payloads(); +/// accepts_serde_data(&payloads); /// # } /// ``` #[derive(Clone, Default, Eq, Ord)]