├── .github ├── FUNDING.yml └── workflows │ └── ci.yml ├── .gitignore ├── tests ├── crate │ ├── lib.rs │ └── Cargo.toml ├── ui │ ├── missing-supertrait.rs │ └── missing-supertrait.stderr ├── compiletest.rs ├── traitobject.rs └── readme.rs ├── src ├── features_check │ ├── error.rs │ └── mod.rs ├── sealed.rs ├── private.rs ├── map.rs ├── any.rs ├── lib.rs ├── macros.rs ├── error.rs ├── ser.rs └── de.rs ├── explanation ├── Cargo.toml └── main.rs ├── LICENSE-MIT ├── Cargo.toml ├── benches ├── bench.rs └── twitter │ └── mod.rs ├── README.md └── LICENSE-APACHE /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: dtolnay 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | /Cargo.lock 3 | -------------------------------------------------------------------------------- /tests/crate/lib.rs: -------------------------------------------------------------------------------- 1 | pub use erased_serde::*; 2 | -------------------------------------------------------------------------------- /src/features_check/error.rs: -------------------------------------------------------------------------------- 1 | "erased-serde requires that either `std` (default) or `alloc` feature is enabled" 2 | -------------------------------------------------------------------------------- /tests/ui/missing-supertrait.rs: -------------------------------------------------------------------------------- 1 | use erased_serde::serialize_trait_object; 2 | 3 | pub trait MyTrait {} 4 | 5 | serialize_trait_object!(MyTrait); 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /src/sealed.rs: -------------------------------------------------------------------------------- 1 | pub mod serialize { 2 | pub trait Sealed {} 3 | } 4 | 5 | pub mod serializer { 6 | pub trait Sealed {} 7 | } 8 | 9 | pub mod deserializer { 10 | pub trait Sealed {} 11 | } 12 | -------------------------------------------------------------------------------- /tests/compiletest.rs: -------------------------------------------------------------------------------- 1 | #[rustversion::attr(not(nightly), ignore = "requires nightly")] 2 | #[cfg_attr(miri, ignore = "incompatible with miri")] 3 | #[test] 4 | fn ui() { 5 | let t = trybuild::TestCases::new(); 6 | t.compile_fail("tests/ui/*.rs"); 7 | } 8 | -------------------------------------------------------------------------------- /explanation/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "erased-serde-explanation" 3 | version = "0.0.0" 4 | authors = ["David Tolnay "] 5 | edition = "2021" 6 | publish = false 7 | 8 | [[bin]] 9 | name = "erased-serde-explanation" 10 | path = "main.rs" 11 | -------------------------------------------------------------------------------- /tests/traitobject.rs: -------------------------------------------------------------------------------- 1 | use erased_serde::serialize_trait_object; 2 | 3 | pub trait MyTrait: erased_serde::Serialize {} 4 | 5 | serialize_trait_object!(MyTrait); 6 | 7 | pub trait MyGenericTrait<'a, T>: erased_serde::Serialize {} 8 | 9 | serialize_trait_object!(<'a, T> MyGenericTrait<'a, T>); 10 | -------------------------------------------------------------------------------- /src/features_check/mod.rs: -------------------------------------------------------------------------------- 1 | //! Shows a user-friendly compiler error on incompatible selected features. 2 | 3 | #[allow(unused_macros)] 4 | macro_rules! hide_from_rustfmt { 5 | ($mod:item) => { 6 | $mod 7 | }; 8 | } 9 | 10 | #[cfg(not(feature = "alloc"))] 11 | hide_from_rustfmt! { 12 | mod error; 13 | } 14 | -------------------------------------------------------------------------------- /tests/crate/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "erased-serde-test" 3 | version = "0.0.0" 4 | authors = ["David Tolnay "] 5 | edition = "2021" 6 | publish = false 7 | 8 | [lib] 9 | path = "lib.rs" 10 | 11 | [features] 12 | default = ["std"] 13 | std = ["erased-serde/std"] 14 | alloc = ["erased-serde/alloc"] 15 | 16 | [dependencies] 17 | erased-serde = { path = "../..", default-features = false } 18 | -------------------------------------------------------------------------------- /src/private.rs: -------------------------------------------------------------------------------- 1 | //! Not public API. Used as `$crate::__private` by macros. 2 | 3 | #[doc(hidden)] 4 | pub mod serde { 5 | #[doc(hidden)] 6 | pub use serde::*; 7 | } 8 | 9 | #[doc(hidden)] 10 | pub use core::marker::{Send, Sized, Sync}; 11 | 12 | #[doc(hidden)] 13 | pub type Result = core::result::Result; 14 | 15 | #[doc(hidden)] 16 | pub fn require_erased_serialize_impl() 17 | where 18 | T: ?Sized + crate::Serialize, 19 | { 20 | } 21 | -------------------------------------------------------------------------------- /src/map.rs: -------------------------------------------------------------------------------- 1 | pub(crate) trait ResultExt { 2 | unsafe fn unsafe_map(self, op: unsafe fn(T) -> U) -> Result; 3 | } 4 | 5 | impl ResultExt for Result { 6 | unsafe fn unsafe_map(self, op: unsafe fn(T) -> U) -> Result { 7 | match self { 8 | Ok(t) => Ok(unsafe { op(t) }), 9 | Err(e) => Err(e), 10 | } 11 | } 12 | } 13 | 14 | pub(crate) trait OptionExt { 15 | unsafe fn unsafe_map(self, op: unsafe fn(T) -> U) -> Option; 16 | } 17 | 18 | impl OptionExt for Option { 19 | unsafe fn unsafe_map(self, op: unsafe fn(T) -> U) -> Option { 20 | match self { 21 | Some(t) => Some(unsafe { op(t) }), 22 | None => None, 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | Permission is hereby granted, free of charge, to any 2 | person obtaining a copy of this software and associated 3 | documentation files (the "Software"), to deal in the 4 | Software without restriction, including without 5 | limitation the rights to use, copy, modify, merge, 6 | publish, distribute, sublicense, and/or sell copies of 7 | the Software, and to permit persons to whom the Software 8 | is furnished to do so, subject to the following 9 | conditions: 10 | 11 | The above copyright notice and this permission notice 12 | shall be included in all copies or substantial portions 13 | of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF 16 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 17 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 18 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 19 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 21 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 22 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 | DEALINGS IN THE SOFTWARE. 24 | -------------------------------------------------------------------------------- /tests/ui/missing-supertrait.stderr: -------------------------------------------------------------------------------- 1 | error[E0277]: the trait bound `__T: serde::Serialize` is not satisfied 2 | --> tests/ui/missing-supertrait.rs:5:1 3 | | 4 | 5 | serialize_trait_object!(MyTrait); 5 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `serde::Serialize` is not implemented for `__T`, so it does not implement `erased_serde::Serialize` 6 | | 7 | = note: required for `__T` to implement `erased_serde::Serialize` 8 | note: required by a bound in `require_erased_serialize_impl` 9 | --> src/private.rs 10 | | 11 | | pub fn require_erased_serialize_impl() 12 | | ----------------------------- required by a bound in this function 13 | | where 14 | | T: ?Sized + crate::Serialize, 15 | | ^^^^^^^^^^^^^^^^ required by this bound in `require_erased_serialize_impl` 16 | = note: this error originates in the macro `$crate::__internal_serialize_trait_object` which comes from the expansion of the macro `serialize_trait_object` (in Nightly builds, run with -Z macro-backtrace for more info) 17 | help: consider further restricting type parameter `__T` with trait `Serialize` 18 | | 19 | 5 | serialize_trait_object!(MyTrait + serde_core::ser::Serialize); 20 | | ++++++++++++++++++++++++++++ 21 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "erased-serde" 3 | version = "0.4.9" 4 | authors = ["David Tolnay "] 5 | categories = ["encoding", "rust-patterns", "no-std"] 6 | description = "Type-erased Serialize and Serializer traits" 7 | documentation = "https://docs.rs/erased-serde" 8 | edition = "2021" 9 | exclude = ["benches"] 10 | keywords = ["serde", "erasure"] 11 | license = "MIT OR Apache-2.0" 12 | repository = "https://github.com/dtolnay/erased-serde" 13 | rust-version = "1.68" 14 | 15 | [dependencies] 16 | serde_core = { version = "1.0.220", default-features = false } 17 | typeid = "1" 18 | 19 | [target.'cfg(any())'.dependencies] 20 | serde = { version = "1.0.220", default-features = false } 21 | 22 | [dev-dependencies] 23 | rustversion = "1.0.13" 24 | serde = "1.0.220" 25 | serde_cbor = "0.11.2" 26 | serde_derive = "1.0.220" 27 | serde_json = "1.0.99" 28 | trybuild = { version = "1.0.108", features = ["diff"] } 29 | 30 | [target.'cfg(not(miri))'.dev-dependencies] 31 | criterion = { version = "0.8", default-features = false } 32 | 33 | [features] 34 | # Note: at least one of "std" or "alloc" must be enabled. 35 | default = ["std"] 36 | std = ["alloc", "serde_core/std"] 37 | alloc = ["serde_core/alloc"] 38 | unstable-debug = [] 39 | 40 | [[test]] 41 | name = "test" 42 | path = "tests/readme.rs" 43 | 44 | [[bench]] 45 | name = "bench" 46 | harness = false 47 | 48 | [workspace] 49 | members = ["explanation", "tests/crate"] 50 | 51 | [package.metadata.docs.rs] 52 | targets = ["x86_64-unknown-linux-gnu"] 53 | rustdoc-args = [ 54 | "--generate-link-to-definition", 55 | "--generate-macro-expansion", 56 | "--extern-html-root-url=core=https://doc.rust-lang.org", 57 | "--extern-html-root-url=alloc=https://doc.rust-lang.org", 58 | "--extern-html-root-url=std=https://doc.rust-lang.org", 59 | ] 60 | -------------------------------------------------------------------------------- /explanation/main.rs: -------------------------------------------------------------------------------- 1 | ///////////////////////////////////////////////////////////////////// 2 | // Suppose these are the real traits from Serde. 3 | 4 | trait Querializer {} 5 | 6 | trait Generic { 7 | // Not object safe because of this generic method. 8 | fn generic_fn(&self, querializer: Q); 9 | } 10 | 11 | impl<'a, T> Querializer for &'a T where T: ?Sized + Querializer {} 12 | 13 | impl<'a, T> Generic for Box 14 | where 15 | T: ?Sized + Generic, 16 | { 17 | fn generic_fn(&self, querializer: Q) { 18 | (**self).generic_fn(querializer) 19 | } 20 | } 21 | 22 | ///////////////////////////////////////////////////////////////////// 23 | // This is an object-safe equivalent that interoperates seamlessly. 24 | 25 | trait ErasedGeneric { 26 | fn erased_fn(&self, querializer: &dyn Querializer); 27 | } 28 | 29 | impl Generic for dyn ErasedGeneric { 30 | // Depending on the trait method signatures and the upstream 31 | // impls, could also implement for: 32 | // 33 | // - &'a dyn ErasedGeneric 34 | // - &'a (dyn ErasedGeneric + Send) 35 | // - &'a (dyn ErasedGeneric + Sync) 36 | // - &'a (dyn ErasedGeneric + Send + Sync) 37 | // - Box 38 | // - Box 39 | // - Box 40 | // - Box 41 | fn generic_fn(&self, querializer: Q) { 42 | self.erased_fn(&querializer) 43 | } 44 | } 45 | 46 | impl ErasedGeneric for T 47 | where 48 | T: Generic, 49 | { 50 | fn erased_fn(&self, querializer: &dyn Querializer) { 51 | self.generic_fn(querializer) 52 | } 53 | } 54 | 55 | fn main() { 56 | struct T; 57 | impl Querializer for T {} 58 | 59 | struct S; 60 | impl Generic for S { 61 | fn generic_fn(&self, _querializer: Q) { 62 | println!("querying the real S"); 63 | } 64 | } 65 | 66 | // Construct a trait object. 67 | let trait_object: Box = Box::new(S); 68 | 69 | // Seamlessly invoke the generic method on the trait object. 70 | // 71 | // THIS LINE LOOKS LIKE MAGIC. We have a value of type trait 72 | // object and we are invoking a generic method on it. 73 | trait_object.generic_fn(T); 74 | } 75 | -------------------------------------------------------------------------------- /tests/readme.rs: -------------------------------------------------------------------------------- 1 | // Please also update README.md when making changes to this code. 2 | 3 | use erased_serde::{Deserializer, Serialize, Serializer}; 4 | use std::collections::BTreeMap as Map; 5 | use std::io; 6 | 7 | #[test] 8 | fn serialization() { 9 | // Construct some serializers. 10 | let json = &mut serde_json::Serializer::new(io::stdout()); 11 | let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout())); 12 | 13 | // The values in this map are boxed trait objects. Ordinarily this would not 14 | // be possible with serde::Serializer because of object safety, but type 15 | // erasure makes it possible with erased_serde::Serializer. 16 | let mut formats: Map<&str, Box> = Map::new(); 17 | formats.insert("json", Box::new(::erase(json))); 18 | formats.insert("cbor", Box::new(::erase(cbor))); 19 | 20 | // These are boxed trait objects as well. Same thing here - type erasure 21 | // makes this possible. 22 | let mut values: Map<&str, Box> = Map::new(); 23 | values.insert("vec", Box::new(vec!["a", "b"])); 24 | values.insert("int", Box::new(65536)); 25 | 26 | // Pick a Serializer out of the formats map. 27 | let format = formats.get_mut("json").unwrap(); 28 | 29 | // Pick a Serialize out of the values map. 30 | let value = values.get("vec").unwrap(); 31 | 32 | // This line prints `["a","b"]` to stdout. 33 | value.erased_serialize(format).unwrap(); 34 | } 35 | 36 | #[test] 37 | fn deserialization() { 38 | static JSON: &[u8] = br#"{"A": 65, "B": 66}"#; 39 | static CBOR: &[u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66]; 40 | 41 | // Construct some deserializers. 42 | let json = &mut serde_json::Deserializer::from_slice(JSON); 43 | let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR); 44 | 45 | // The values in this map are boxed trait objects, which is not possible 46 | // with the normal serde::Deserializer because of object safety. 47 | let mut formats: Map<&str, Box> = Map::new(); 48 | formats.insert("json", Box::new(::erase(json))); 49 | formats.insert("cbor", Box::new(::erase(cbor))); 50 | 51 | // Pick a Deserializer out of the formats map. 52 | let format = formats.get_mut("json").unwrap(); 53 | 54 | let data: Map = erased_serde::deserialize(format).unwrap(); 55 | 56 | println!("{}", data["A"] + data["B"]); 57 | } 58 | -------------------------------------------------------------------------------- /benches/bench.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::struct_excessive_bools, clippy::struct_field_names)] 2 | 3 | mod twitter; 4 | 5 | use crate::twitter::Twitter; 6 | use criterion::{criterion_group, criterion_main, Bencher, Criterion}; 7 | use std::fs; 8 | 9 | fn serialize_twitter_monomorphized(b: &mut Bencher) { 10 | let bytes = fs::read("benches/twitter.json").unwrap(); 11 | let value: Twitter = serde_json::from_slice(&bytes).unwrap(); 12 | let mut buf = Vec::with_capacity(bytes.len()); 13 | b.iter(|| { 14 | buf.clear(); 15 | let mut serializer = serde_json::Serializer::new(&mut buf); 16 | serde::Serialize::serialize(&value, &mut serializer).unwrap(); 17 | }); 18 | } 19 | 20 | fn serialize_twitter_erased(b: &mut Bencher) { 21 | let bytes = fs::read("benches/twitter.json").unwrap(); 22 | let value: Twitter = serde_json::from_slice(&bytes).unwrap(); 23 | let mut buf = Vec::with_capacity(bytes.len()); 24 | b.iter(|| { 25 | buf.clear(); 26 | let erased_value = &value as &dyn erased_serde::Serialize; 27 | let mut serializer = serde_json::Serializer::new(&mut buf); 28 | let mut erased_serializer = ::erase(&mut serializer); 29 | erased_value 30 | .erased_serialize(&mut erased_serializer) 31 | .unwrap(); 32 | }); 33 | } 34 | 35 | fn twitter_to_json_value_monomorphized(b: &mut Bencher) { 36 | let bytes = fs::read("benches/twitter.json").unwrap(); 37 | let value: Twitter = serde_json::from_slice(&bytes).unwrap(); 38 | b.iter(|| -> serde_json::Value { 39 | let serializer = serde_json::value::Serializer; 40 | serde::Serialize::serialize(&value, serializer).unwrap() 41 | }); 42 | } 43 | 44 | fn twitter_to_json_value_erased(b: &mut Bencher) { 45 | let bytes = fs::read("benches/twitter.json").unwrap(); 46 | let value: Twitter = serde_json::from_slice(&bytes).unwrap(); 47 | b.iter(|| -> serde_json::Value { 48 | let erased_value = &value as &dyn erased_serde::Serialize; 49 | let serializer = serde_json::value::Serializer; 50 | erased_serde::serialize(erased_value, serializer).unwrap() 51 | }); 52 | } 53 | 54 | fn bench(c: &mut Criterion) { 55 | let mut group = c.benchmark_group("serialize_twitter"); 56 | group.bench_function("monomorphized", serialize_twitter_monomorphized); 57 | group.bench_function("erased", serialize_twitter_erased); 58 | group.finish(); 59 | 60 | let mut group = c.benchmark_group("twitter_to_json_value"); 61 | group.bench_function("monomorphized", twitter_to_json_value_monomorphized); 62 | group.bench_function("erased", twitter_to_json_value_erased); 63 | group.finish(); 64 | } 65 | 66 | criterion_group!(benches, bench); 67 | criterion_main!(benches); 68 | -------------------------------------------------------------------------------- /.github/workflows/ci.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: 4 | push: 5 | pull_request: 6 | workflow_dispatch: 7 | schedule: [cron: "40 1 * * *"] 8 | 9 | permissions: 10 | contents: read 11 | 12 | env: 13 | RUSTFLAGS: -Dwarnings 14 | 15 | jobs: 16 | pre_ci: 17 | uses: dtolnay/.github/.github/workflows/pre_ci.yml@master 18 | 19 | test: 20 | name: Rust ${{matrix.rust}} 21 | needs: pre_ci 22 | if: needs.pre_ci.outputs.continue 23 | runs-on: ubuntu-latest 24 | strategy: 25 | fail-fast: false 26 | matrix: 27 | rust: [nightly, beta, stable, 1.86.0, 1.68.0] 28 | timeout-minutes: 45 29 | steps: 30 | - uses: actions/checkout@v6 31 | - uses: dtolnay/rust-toolchain@master 32 | with: 33 | toolchain: ${{matrix.rust}} 34 | - name: Enable type layout randomization 35 | run: echo RUSTFLAGS=${RUSTFLAGS}\ -Zrandomize-layout >> $GITHUB_ENV 36 | if: matrix.rust == 'nightly' 37 | - run: cargo check 38 | - run: cargo check --manifest-path tests/crate/Cargo.toml 39 | - run: cargo check --manifest-path tests/crate/Cargo.toml --no-default-features --features alloc 40 | - run: cargo test 41 | if: matrix.rust != '1.68.0' 42 | - uses: actions/upload-artifact@v6 43 | if: matrix.rust == 'nightly' && always() 44 | with: 45 | name: Cargo.lock 46 | path: Cargo.lock 47 | continue-on-error: true 48 | 49 | minimal: 50 | name: Minimal versions 51 | needs: pre_ci 52 | if: needs.pre_ci.outputs.continue 53 | runs-on: ubuntu-latest 54 | timeout-minutes: 45 55 | steps: 56 | - uses: actions/checkout@v6 57 | - uses: dtolnay/rust-toolchain@nightly 58 | - run: cargo generate-lockfile -Z minimal-versions 59 | - run: cargo check --locked 60 | 61 | doc: 62 | name: Documentation 63 | needs: pre_ci 64 | if: needs.pre_ci.outputs.continue 65 | runs-on: ubuntu-latest 66 | timeout-minutes: 45 67 | env: 68 | RUSTDOCFLAGS: -Dwarnings 69 | steps: 70 | - uses: actions/checkout@v6 71 | - uses: dtolnay/rust-toolchain@nightly 72 | - uses: dtolnay/install@cargo-docs-rs 73 | - run: cargo docs-rs 74 | 75 | clippy: 76 | name: Clippy 77 | runs-on: ubuntu-latest 78 | if: github.event_name != 'pull_request' 79 | timeout-minutes: 45 80 | steps: 81 | - uses: actions/checkout@v6 82 | - uses: dtolnay/rust-toolchain@clippy 83 | - run: cargo clippy --tests --benches -- -Dclippy::all -Dclippy::pedantic 84 | 85 | miri: 86 | name: Miri 87 | needs: pre_ci 88 | if: needs.pre_ci.outputs.continue 89 | runs-on: ubuntu-latest 90 | timeout-minutes: 45 91 | steps: 92 | - uses: actions/checkout@v6 93 | - uses: dtolnay/rust-toolchain@miri 94 | - run: cargo miri setup 95 | - run: cargo miri test 96 | env: 97 | MIRIFLAGS: -Zmiri-strict-provenance 98 | 99 | outdated: 100 | name: Outdated 101 | runs-on: ubuntu-latest 102 | if: github.event_name != 'pull_request' 103 | timeout-minutes: 45 104 | steps: 105 | - uses: actions/checkout@v6 106 | - uses: dtolnay/rust-toolchain@stable 107 | - uses: dtolnay/install@cargo-outdated 108 | - run: cargo outdated --workspace --exit-code 1 109 | -------------------------------------------------------------------------------- /src/any.rs: -------------------------------------------------------------------------------- 1 | use alloc::boxed::Box; 2 | use core::any::TypeId; 3 | use core::mem::{self, MaybeUninit}; 4 | use core::ptr; 5 | 6 | #[cfg(feature = "unstable-debug")] 7 | use core::any; 8 | 9 | pub struct Any { 10 | value: Value, 11 | drop: unsafe fn(&mut Value), 12 | type_id: TypeId, 13 | 14 | /// For panic messages only. Not used for comparison. 15 | #[cfg(feature = "unstable-debug")] 16 | type_name: &'static str, 17 | } 18 | 19 | union Value { 20 | ptr: *mut (), 21 | inline: [MaybeUninit; 2], 22 | } 23 | 24 | fn is_small() -> bool { 25 | mem::size_of::() <= mem::size_of::() 26 | && mem::align_of::() <= mem::align_of::() 27 | } 28 | 29 | impl Any { 30 | // This is unsafe -- caller must not hold on to the Any beyond the lifetime 31 | // of T. 32 | // 33 | // Example of bad code: 34 | // 35 | // let s = "bad".to_owned(); 36 | // let a = Any::new(&s); 37 | // drop(s); 38 | // 39 | // Now `a.as_ref()` and `a.take()` return references to a dead String. 40 | pub(crate) unsafe fn new(t: T) -> Self { 41 | let value: Value; 42 | let drop: unsafe fn(&mut Value); 43 | let type_id = typeid::of::(); 44 | 45 | if is_small::() { 46 | let mut inline = [MaybeUninit::uninit(); 2]; 47 | unsafe { ptr::write(inline.as_mut_ptr().cast::(), t) }; 48 | value = Value { inline }; 49 | unsafe fn inline_drop(value: &mut Value) { 50 | unsafe { ptr::drop_in_place(value.inline.as_mut_ptr().cast::()) } 51 | } 52 | drop = inline_drop::; 53 | } else { 54 | let ptr = Box::into_raw(Box::new(t)).cast::<()>(); 55 | value = Value { ptr }; 56 | unsafe fn ptr_drop(value: &mut Value) { 57 | mem::drop(unsafe { Box::from_raw(value.ptr.cast::()) }); 58 | } 59 | drop = ptr_drop::; 60 | } 61 | 62 | Any { 63 | value, 64 | drop, 65 | type_id, 66 | #[cfg(feature = "unstable-debug")] 67 | type_name: any::type_name::(), 68 | } 69 | } 70 | 71 | // This is unsafe -- caller is responsible that T is the correct type. 72 | pub(crate) unsafe fn take(mut self) -> T { 73 | if self.type_id != typeid::of::() { 74 | self.invalid_cast_to::(); 75 | } 76 | 77 | if is_small::() { 78 | let ptr = unsafe { self.value.inline.as_mut_ptr().cast::() }; 79 | let value = unsafe { ptr::read(ptr) }; 80 | mem::forget(self); 81 | value 82 | } else { 83 | let ptr = unsafe { self.value.ptr.cast::() }; 84 | let box_t = unsafe { Box::from_raw(ptr) }; 85 | mem::forget(self); 86 | *box_t 87 | } 88 | } 89 | 90 | #[cfg(not(feature = "unstable-debug"))] 91 | fn invalid_cast_to(&self) -> ! { 92 | panic!("invalid cast; enable `unstable-debug` feature to debug"); 93 | } 94 | 95 | #[cfg(feature = "unstable-debug")] 96 | fn invalid_cast_to(&self) -> ! { 97 | let from = self.type_name; 98 | let to = any::type_name::(); 99 | panic!("invalid cast: {} to {}", from, to); 100 | } 101 | } 102 | 103 | impl Drop for Any { 104 | fn drop(&mut self) { 105 | unsafe { (self.drop)(&mut self.value) } 106 | } 107 | } 108 | -------------------------------------------------------------------------------- /src/lib.rs: -------------------------------------------------------------------------------- 1 | //! [![github]](https://github.com/dtolnay/erased-serde) [![crates-io]](https://crates.io/crates/erased-serde) [![docs-rs]](https://docs.rs/erased-serde) 2 | //! 3 | //! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github 4 | //! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust 5 | //! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs 6 | //! 7 | //!
8 | //! 9 | //! This crate provides type-erased versions of Serde's `Serialize`, `Serializer` 10 | //! and `Deserializer` traits that can be used as [trait objects]. 11 | //! 12 | //! [trait objects]: https://doc.rust-lang.org/book/trait-objects.html 13 | //! 14 | //! The usual Serde `Serialize`, `Serializer` and `Deserializer` traits cannot 15 | //! be used as trait objects like `&dyn Serialize` or boxed trait objects like 16 | //! `Box` because of Rust's ["object safety" rules]. In 17 | //! particular, all three traits contain generic methods which cannot be made 18 | //! into a trait object. 19 | //! 20 | //! ["object safety" rules]: http://huonw.github.io/blog/2015/01/object-safety/ 21 | //! 22 | //! This library should be considered a low-level building block for interacting 23 | //! with Serde APIs in an object-safe way. Most use cases will require higher 24 | //! level functionality such as provided by [`typetag`] which uses this crate 25 | //! internally. 26 | //! 27 | //! [`typetag`]: https://github.com/dtolnay/typetag 28 | //! 29 | //! **The traits in this crate work seamlessly with any existing Serde 30 | //! `Serialize` and `Deserialize` type and any existing Serde `Serializer` and 31 | //! `Deserializer` format.** 32 | //! 33 | //! ## Serialization 34 | //! 35 | //! ```rust 36 | //! use erased_serde::{Serialize, Serializer}; 37 | //! use std::collections::BTreeMap as Map; 38 | //! use std::io; 39 | //! 40 | //! fn main() { 41 | //! // Construct some serializers. 42 | //! let json = &mut serde_json::Serializer::new(io::stdout()); 43 | //! let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout())); 44 | //! 45 | //! // The values in this map are boxed trait objects. Ordinarily this would not 46 | //! // be possible with serde::Serializer because of object safety, but type 47 | //! // erasure makes it possible with erased_serde::Serializer. 48 | //! let mut formats: Map<&str, Box> = Map::new(); 49 | //! formats.insert("json", Box::new(::erase(json))); 50 | //! formats.insert("cbor", Box::new(::erase(cbor))); 51 | //! 52 | //! // These are boxed trait objects as well. Same thing here - type erasure 53 | //! // makes this possible. 54 | //! let mut values: Map<&str, Box> = Map::new(); 55 | //! values.insert("vec", Box::new(vec!["a", "b"])); 56 | //! values.insert("int", Box::new(65536)); 57 | //! 58 | //! // Pick a Serializer out of the formats map. 59 | //! let format = formats.get_mut("json").unwrap(); 60 | //! 61 | //! // Pick a Serialize out of the values map. 62 | //! let value = values.get("vec").unwrap(); 63 | //! 64 | //! // This line prints `["a","b"]` to stdout. 65 | //! value.erased_serialize(format).unwrap(); 66 | //! } 67 | //! ``` 68 | //! 69 | //! ## Deserialization 70 | //! 71 | //! ```rust 72 | //! use erased_serde::Deserializer; 73 | //! use std::collections::BTreeMap as Map; 74 | //! 75 | //! fn main() { 76 | //! static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#; 77 | //! static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66]; 78 | //! 79 | //! // Construct some deserializers. 80 | //! let json = &mut serde_json::Deserializer::from_slice(JSON); 81 | //! let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR); 82 | //! 83 | //! // The values in this map are boxed trait objects, which is not possible 84 | //! // with the normal serde::Deserializer because of object safety. 85 | //! let mut formats: Map<&str, Box> = Map::new(); 86 | //! formats.insert("json", Box::new(::erase(json))); 87 | //! formats.insert("cbor", Box::new(::erase(cbor))); 88 | //! 89 | //! // Pick a Deserializer out of the formats map. 90 | //! let format = formats.get_mut("json").unwrap(); 91 | //! 92 | //! let data: Map = erased_serde::deserialize(format).unwrap(); 93 | //! 94 | //! println!("{}", data["A"] + data["B"]); 95 | //! } 96 | //! ``` 97 | 98 | #![doc(html_root_url = "https://docs.rs/erased-serde/0.4.9")] 99 | #![no_std] 100 | #![deny(unsafe_op_in_unsafe_fn)] 101 | #![allow( 102 | clippy::box_collection, 103 | clippy::derive_partial_eq_without_eq, 104 | clippy::extra_unused_type_parameters, 105 | clippy::items_after_statements, 106 | clippy::manual_map, // https://github.com/rust-lang/rust-clippy/issues/7820 107 | clippy::missing_errors_doc, 108 | clippy::needless_doctest_main, 109 | clippy::needless_pass_by_ref_mut, 110 | clippy::needless_pass_by_value, 111 | clippy::semicolon_if_nothing_returned, // https://github.com/rust-lang/rust-clippy/issues/7324 112 | clippy::similar_names, 113 | clippy::struct_field_names, 114 | clippy::unused_self, 115 | clippy::wildcard_imports 116 | )] 117 | #![allow(unknown_lints, mismatched_lifetime_syntaxes)] 118 | 119 | extern crate alloc; 120 | 121 | #[cfg(feature = "std")] 122 | extern crate std; 123 | 124 | extern crate serde_core as serde; 125 | 126 | #[macro_use] 127 | mod macros; 128 | 129 | mod any; 130 | mod de; 131 | mod error; 132 | mod features_check; 133 | mod map; 134 | mod sealed; 135 | mod ser; 136 | 137 | pub use crate::de::{deserialize, Deserializer}; 138 | pub use crate::error::{Error, Result}; 139 | pub use crate::ser::{serialize, Serialize, Serializer}; 140 | 141 | // Not public API. 142 | #[doc(hidden)] 143 | #[path = "private.rs"] 144 | pub mod __private; 145 | -------------------------------------------------------------------------------- /src/macros.rs: -------------------------------------------------------------------------------- 1 | /// Implement `serde::Serialize` for a trait object that has 2 | /// `erased_serde::Serialize` as a supertrait. 3 | /// 4 | /// ``` 5 | /// use erased_serde::serialize_trait_object; 6 | /// 7 | /// trait Event: erased_serde::Serialize { 8 | /// /* ... */ 9 | /// } 10 | /// 11 | /// erased_serde::serialize_trait_object!(Event); 12 | /// ``` 13 | /// 14 | /// The macro supports traits that have type parameters and/or `where` clauses. 15 | /// 16 | /// ``` 17 | /// # use erased_serde::serialize_trait_object; 18 | /// # 19 | /// trait Difficult: erased_serde::Serialize where T: Copy { 20 | /// /* ... */ 21 | /// } 22 | /// 23 | /// serialize_trait_object!( Difficult where T: Copy); 24 | /// ``` 25 | #[macro_export] 26 | macro_rules! serialize_trait_object { 27 | ($($path:tt)+) => { 28 | $crate::__internal_serialize_trait_object!(begin $($path)+); 29 | }; 30 | } 31 | 32 | #[doc(hidden)] 33 | #[macro_export] 34 | macro_rules! __internal_serialize_trait_object { 35 | // Invocation started with `<`, parse generics. 36 | (begin < $($rest:tt)*) => { 37 | $crate::__internal_serialize_trait_object!(generics () () $($rest)*); 38 | }; 39 | 40 | // Invocation did not start with `<`. 41 | (begin $first:tt $($rest:tt)*) => { 42 | $crate::__internal_serialize_trait_object!(path () ($first) $($rest)*); 43 | }; 44 | 45 | // End of generics with trailing comma. 46 | (generics ($($generics:tt)*) () , > $($rest:tt)*) => { 47 | $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*); 48 | }; 49 | 50 | // End of generics without trailing comma. 51 | (generics ($($generics:tt)*) () > $($rest:tt)*) => { 52 | $crate::__internal_serialize_trait_object!(path ($($generics)* ,) () $($rest)*); 53 | }; 54 | 55 | // Generics open bracket. 56 | (generics ($($generics:tt)*) ($($brackets:tt)*) < $($rest:tt)*) => { 57 | $crate::__internal_serialize_trait_object!(generics ($($generics)* <) ($($brackets)* <) $($rest)*); 58 | }; 59 | 60 | // Generics close bracket. 61 | (generics ($($generics:tt)*) (< $($brackets:tt)*) > $($rest:tt)*) => { 62 | $crate::__internal_serialize_trait_object!(generics ($($generics)* >) ($($brackets)*) $($rest)*); 63 | }; 64 | 65 | // Token inside of generics. 66 | (generics ($($generics:tt)*) ($($brackets:tt)*) $first:tt $($rest:tt)*) => { 67 | $crate::__internal_serialize_trait_object!(generics ($($generics)* $first) ($($brackets)*) $($rest)*); 68 | }; 69 | 70 | // End with `where` clause. 71 | (path ($($generics:tt)*) ($($path:tt)*) where $($rest:tt)*) => { 72 | $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ($($rest)*)); 73 | }; 74 | 75 | // End without `where` clause. 76 | (path ($($generics:tt)*) ($($path:tt)*)) => { 77 | $crate::__internal_serialize_trait_object!(sendsync ($($generics)*) ($($path)*) ()); 78 | }; 79 | 80 | // Token inside of path. 81 | (path ($($generics:tt)*) ($($path:tt)*) $first:tt $($rest:tt)*) => { 82 | $crate::__internal_serialize_trait_object!(path ($($generics)*) ($($path)* $first) $($rest)*); 83 | }; 84 | 85 | // Expand into four impls. 86 | (sendsync ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*)) => { 87 | $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)*) ($($bound)*) { 88 | fn __check_erased_serialize_supertrait<$($generics)* __T>() 89 | where 90 | __T: ?$crate::__private::Sized + $($path)*, 91 | $($bound)* 92 | { 93 | $crate::__private::require_erased_serialize_impl::<__T>(); 94 | } 95 | }); 96 | $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send) ($($bound)*)); 97 | $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Sync) ($($bound)*)); 98 | $crate::__internal_serialize_trait_object!(impl ($($generics)*) ($($path)* + $crate::__private::Send + $crate::__private::Sync) ($($bound)*)); 99 | }; 100 | 101 | // The impl. 102 | (impl ($($generics:tt)*) ($($path:tt)*) ($($bound:tt)*) $({$($body:tt)*})*) => { 103 | impl<'erased, $($generics)*> $crate::__private::serde::Serialize for dyn $($path)* + 'erased 104 | where 105 | $($bound)* 106 | { 107 | fn serialize(&self, serializer: S) -> $crate::__private::Result 108 | where 109 | S: $crate::__private::serde::Serializer, 110 | { 111 | $($($body)*)* 112 | $crate::serialize(self, serializer) 113 | } 114 | } 115 | }; 116 | } 117 | 118 | macro_rules! return_impl_trait { 119 | ( 120 | $(#[$attr:meta])* 121 | $vis:vis fn $name:ident <$param:ident> $args:tt -> $impl_trait:ty [$concrete:ty] $($body:tt)+ 122 | ) => { 123 | #[cfg(not(docsrs))] 124 | $(#[$attr])* 125 | $vis fn $name <$param> $args -> $concrete $($body)+ 126 | 127 | #[cfg(docsrs)] 128 | $(#[$attr])* 129 | $vis fn $name <$param> $args -> $impl_trait $($body)+ 130 | }; 131 | } 132 | 133 | // TEST //////////////////////////////////////////////////////////////////////// 134 | 135 | #[cfg(test)] 136 | mod tests { 137 | use crate::Serialize; 138 | 139 | fn assert_serialize() {} 140 | 141 | #[test] 142 | fn test_plain() { 143 | trait Trait: Serialize {} 144 | 145 | serialize_trait_object!(Trait); 146 | assert_serialize::(); 147 | assert_serialize::(); 148 | } 149 | 150 | #[test] 151 | fn test_type_parameter() { 152 | trait Trait: Serialize {} 153 | 154 | serialize_trait_object!( Trait); 155 | assert_serialize::>(); 156 | assert_serialize:: + Send>(); 157 | } 158 | 159 | #[test] 160 | fn test_generic_bound() { 161 | trait Trait, U>: Serialize {} 162 | 163 | serialize_trait_object!(, U> Trait); 164 | assert_serialize::>(); 165 | assert_serialize:: + Send>(); 166 | } 167 | 168 | #[test] 169 | fn test_where_clause() { 170 | trait Trait: Serialize 171 | where 172 | T: Clone, 173 | { 174 | } 175 | 176 | serialize_trait_object!( Trait where T: Clone); 177 | assert_serialize::>(); 178 | assert_serialize:: + Send>(); 179 | } 180 | } 181 | -------------------------------------------------------------------------------- /benches/twitter/mod.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::{Deserialize, Serialize}; 2 | 3 | #[derive(Serialize, Deserialize)] 4 | #[serde(deny_unknown_fields)] 5 | pub struct Twitter<'a> { 6 | #[serde(borrow)] 7 | pub statuses: Vec>, 8 | #[serde(borrow)] 9 | pub search_metadata: SearchMetadata<'a>, 10 | } 11 | 12 | pub type LongId = u64; 13 | pub type ShortId = u32; 14 | 15 | #[derive(Serialize, Deserialize)] 16 | #[serde(deny_unknown_fields)] 17 | pub struct Status<'a> { 18 | #[serde(borrow)] 19 | pub metadata: Metadata<'a>, 20 | pub created_at: &'a str, 21 | pub id: LongId, 22 | pub id_str: &'a str, 23 | pub text: String, 24 | pub source: String, 25 | pub truncated: bool, 26 | pub in_reply_to_status_id: Option, 27 | #[serde(borrow)] 28 | pub in_reply_to_status_id_str: Option<&'a str>, 29 | pub in_reply_to_user_id: Option, 30 | #[serde(borrow)] 31 | pub in_reply_to_user_id_str: Option<&'a str>, 32 | #[serde(borrow)] 33 | pub in_reply_to_screen_name: Option<&'a str>, 34 | #[serde(borrow)] 35 | pub user: User<'a>, 36 | pub geo: (), 37 | pub coordinates: (), 38 | pub place: (), 39 | pub contributors: (), 40 | #[serde(borrow)] 41 | pub retweeted_status: Option>>, 42 | pub retweet_count: u32, 43 | pub favorite_count: u32, 44 | #[serde(borrow)] 45 | pub entities: StatusEntities<'a>, 46 | pub favorited: bool, 47 | pub retweeted: bool, 48 | pub possibly_sensitive: Option, 49 | pub lang: &'a str, 50 | } 51 | 52 | #[derive(Serialize, Deserialize)] 53 | #[serde(deny_unknown_fields)] 54 | pub struct Metadata<'a> { 55 | pub result_type: &'a str, 56 | pub iso_language_code: &'a str, 57 | } 58 | 59 | #[derive(Serialize, Deserialize)] 60 | #[serde(deny_unknown_fields)] 61 | pub struct User<'a> { 62 | pub id: ShortId, 63 | pub id_str: &'a str, 64 | pub name: &'a str, 65 | pub screen_name: &'a str, 66 | pub location: &'a str, 67 | pub description: String, 68 | #[serde(borrow)] 69 | pub url: Option<&'a str>, 70 | #[serde(borrow)] 71 | pub entities: UserEntities<'a>, 72 | pub protected: bool, 73 | pub followers_count: u32, 74 | pub friends_count: u32, 75 | pub listed_count: u32, 76 | pub created_at: &'a str, 77 | pub favourites_count: u32, 78 | pub utc_offset: Option, 79 | #[serde(borrow)] 80 | pub time_zone: Option<&'a str>, 81 | pub geo_enabled: bool, 82 | pub verified: bool, 83 | pub statuses_count: u32, 84 | pub lang: &'a str, 85 | pub contributors_enabled: bool, 86 | pub is_translator: bool, 87 | pub is_translation_enabled: bool, 88 | pub profile_background_color: &'a str, 89 | pub profile_background_image_url: &'a str, 90 | pub profile_background_image_url_https: &'a str, 91 | pub profile_background_tile: bool, 92 | pub profile_image_url: &'a str, 93 | pub profile_image_url_https: &'a str, 94 | #[serde(borrow)] 95 | pub profile_banner_url: Option<&'a str>, 96 | pub profile_link_color: &'a str, 97 | pub profile_sidebar_border_color: &'a str, 98 | pub profile_sidebar_fill_color: &'a str, 99 | pub profile_text_color: &'a str, 100 | pub profile_use_background_image: bool, 101 | pub default_profile: bool, 102 | pub default_profile_image: bool, 103 | pub following: bool, 104 | pub follow_request_sent: bool, 105 | pub notifications: bool, 106 | } 107 | 108 | #[derive(Serialize, Deserialize)] 109 | #[serde(deny_unknown_fields)] 110 | pub struct UserEntities<'a> { 111 | #[serde(borrow)] 112 | pub url: Option>, 113 | #[serde(borrow)] 114 | pub description: UserEntitiesDescription<'a>, 115 | } 116 | 117 | #[derive(Serialize, Deserialize)] 118 | #[serde(deny_unknown_fields)] 119 | pub struct UserUrl<'a> { 120 | #[serde(borrow)] 121 | pub urls: Vec>, 122 | } 123 | 124 | #[derive(Serialize, Deserialize)] 125 | #[serde(deny_unknown_fields)] 126 | pub struct Url<'a> { 127 | pub url: &'a str, 128 | pub expanded_url: &'a str, 129 | pub display_url: &'a str, 130 | pub indices: Indices, 131 | } 132 | 133 | #[derive(Serialize, Deserialize)] 134 | #[serde(deny_unknown_fields)] 135 | pub struct UserEntitiesDescription<'a> { 136 | #[serde(borrow)] 137 | pub urls: Vec>, 138 | } 139 | 140 | #[derive(Serialize, Deserialize)] 141 | #[serde(deny_unknown_fields)] 142 | pub struct StatusEntities<'a> { 143 | #[serde(borrow)] 144 | pub hashtags: Vec>, 145 | pub symbols: [(); 0], 146 | #[serde(borrow)] 147 | pub urls: Vec>, 148 | #[serde(borrow)] 149 | pub user_mentions: Vec>, 150 | #[serde(borrow)] 151 | pub media: Option>>, 152 | } 153 | 154 | #[derive(Serialize, Deserialize)] 155 | #[serde(deny_unknown_fields)] 156 | pub struct Hashtag<'a> { 157 | pub text: &'a str, 158 | pub indices: Indices, 159 | } 160 | 161 | #[derive(Serialize, Deserialize)] 162 | #[serde(deny_unknown_fields)] 163 | pub struct UserMention<'a> { 164 | pub screen_name: &'a str, 165 | pub name: &'a str, 166 | pub id: ShortId, 167 | pub id_str: &'a str, 168 | pub indices: Indices, 169 | } 170 | 171 | #[derive(Serialize, Deserialize)] 172 | #[serde(deny_unknown_fields)] 173 | pub struct Media<'a> { 174 | pub id: LongId, 175 | pub id_str: &'a str, 176 | pub indices: Indices, 177 | pub media_url: &'a str, 178 | pub media_url_https: &'a str, 179 | pub url: &'a str, 180 | pub display_url: &'a str, 181 | pub expanded_url: &'a str, 182 | #[serde(rename = "type")] 183 | pub media_type: &'a str, 184 | #[serde(borrow)] 185 | pub sizes: Sizes<'a>, 186 | pub source_status_id: Option, 187 | #[serde(borrow)] 188 | pub source_status_id_str: Option<&'a str>, 189 | } 190 | 191 | #[derive(Serialize, Deserialize)] 192 | #[serde(deny_unknown_fields)] 193 | pub struct Sizes<'a> { 194 | #[serde(borrow)] 195 | pub medium: Size<'a>, 196 | #[serde(borrow)] 197 | pub small: Size<'a>, 198 | #[serde(borrow)] 199 | pub thumb: Size<'a>, 200 | #[serde(borrow)] 201 | pub large: Size<'a>, 202 | } 203 | 204 | #[derive(Serialize, Deserialize)] 205 | #[serde(deny_unknown_fields)] 206 | pub struct Size<'a> { 207 | pub w: u16, 208 | pub h: u16, 209 | pub resize: &'a str, 210 | } 211 | 212 | pub type Indices = (u8, u8); 213 | 214 | #[derive(Serialize, Deserialize)] 215 | #[serde(deny_unknown_fields)] 216 | pub struct SearchMetadata<'a> { 217 | pub completed_in: f32, 218 | pub max_id: LongId, 219 | pub max_id_str: &'a str, 220 | pub next_results: &'a str, 221 | pub query: &'a str, 222 | pub refresh_url: &'a str, 223 | pub count: u8, 224 | pub since_id: LongId, 225 | pub since_id_str: &'a str, 226 | } 227 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Erased Serde 2 | ============ 3 | 4 | [github](https://github.com/dtolnay/erased-serde) 5 | [crates.io](https://crates.io/crates/erased-serde) 6 | [docs.rs](https://docs.rs/erased-serde) 7 | [build status](https://github.com/dtolnay/erased-serde/actions?query=branch%3Amaster) 8 | 9 | This crate provides type-erased versions of Serde's `Serialize`, `Serializer` 10 | and `Deserializer` traits that can be used as [trait objects]. 11 | 12 | [trait objects]: https://doc.rust-lang.org/book/first-edition/trait-objects.html 13 | 14 | - [`erased_serde::Serialize`](https://docs.rs/erased-serde/0.4/erased_serde/trait.Serialize.html) 15 | - [`erased_serde::Serializer`](https://docs.rs/erased-serde/0.4/erased_serde/trait.Serializer.html) 16 | - [`erased_serde::Deserializer`](https://docs.rs/erased-serde/0.4/erased_serde/trait.Deserializer.html) 17 | 18 | The usual Serde `Serialize`, `Serializer` and `Deserializer` traits cannot be 19 | used as trait objects like `&dyn Serialize` or boxed trait objects like 20 | `Box` because of Rust's ["object safety" rules]. In particular, 21 | all three traits contain generic methods which cannot be made into a trait 22 | object. 23 | 24 | ["object safety" rules]: http://huonw.github.io/blog/2015/01/object-safety/ 25 | 26 | This library should be considered a low-level building block for interacting 27 | with Serde APIs in an object-safe way. Most use cases will require higher level 28 | functionality such as provided by [`typetag`] which uses this crate internally. 29 | 30 | [`typetag`]: https://github.com/dtolnay/typetag 31 | 32 | **The traits in this crate work seamlessly with any existing Serde `Serialize` 33 | and `Deserialize` type and any existing Serde `Serializer` and `Deserializer` 34 | format.** 35 | 36 | ```toml 37 | [dependencies] 38 | serde = "1.0" 39 | erased-serde = "0.4" 40 | ``` 41 | 42 | ## Serialization 43 | 44 | ```rust 45 | use erased_serde::{Serialize, Serializer}; 46 | use std::collections::BTreeMap as Map; 47 | use std::io; 48 | 49 | fn main() { 50 | // Construct some serializers. 51 | let json = &mut serde_json::Serializer::new(io::stdout()); 52 | let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout())); 53 | 54 | // The values in this map are boxed trait objects. Ordinarily this would not 55 | // be possible with serde::Serializer because of object safety, but type 56 | // erasure makes it possible with erased_serde::Serializer. 57 | let mut formats: Map<&str, Box> = Map::new(); 58 | formats.insert("json", Box::new(::erase(json))); 59 | formats.insert("cbor", Box::new(::erase(cbor))); 60 | 61 | // These are boxed trait objects as well. Same thing here - type erasure 62 | // makes this possible. 63 | let mut values: Map<&str, Box> = Map::new(); 64 | values.insert("vec", Box::new(vec!["a", "b"])); 65 | values.insert("int", Box::new(65536)); 66 | 67 | // Pick a Serializer out of the formats map. 68 | let format = formats.get_mut("json").unwrap(); 69 | 70 | // Pick a Serialize out of the values map. 71 | let value = values.get("vec").unwrap(); 72 | 73 | // This line prints `["a","b"]` to stdout. 74 | value.erased_serialize(format).unwrap(); 75 | } 76 | ``` 77 | 78 | ## Deserialization 79 | 80 | ```rust 81 | use erased_serde::Deserializer; 82 | use std::collections::BTreeMap as Map; 83 | 84 | fn main() { 85 | static JSON: &[u8] = br#"{"A": 65, "B": 66}"#; 86 | static CBOR: &[u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66]; 87 | 88 | // Construct some deserializers. 89 | let json = &mut serde_json::Deserializer::from_slice(JSON); 90 | let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR); 91 | 92 | // The values in this map are boxed trait objects, which is not possible 93 | // with the normal serde::Deserializer because of object safety. 94 | let mut formats: Map<&str, Box> = Map::new(); 95 | formats.insert("json", Box::new(::erase(json))); 96 | formats.insert("cbor", Box::new(::erase(cbor))); 97 | 98 | // Pick a Deserializer out of the formats map. 99 | let format = formats.get_mut("json").unwrap(); 100 | 101 | let data: Map = erased_serde::deserialize(format).unwrap(); 102 | 103 | println!("{}", data["A"] + data["B"]); 104 | } 105 | ``` 106 | 107 | ## How it works 108 | 109 | This crate is based on a general technique for building trait objects of traits 110 | that have generic methods (like all of Serde's traits). [This example code] 111 | demonstrates the technique applied to a simplified case of a single generic 112 | method. [Try it in the playground.] 113 | 114 | [This example code]: https://github.com/dtolnay/erased-serde/blob/master/explanation/main.rs 115 | [Try it in the playground.]: https://play.rust-lang.org/?gist=c1111875e7462ba3d0190aacb2fc2211 116 | 117 | In erased-serde things are a bit more complicated than in the example for three 118 | reasons but the idea is the same. 119 | 120 | - We need to deal with trait methods that take `self` by value -- effectively by 121 | implementing the object-safe trait for `Option` where `T` implements the 122 | real trait. 123 | - We need to deal with traits that have associated types like `Serializer::Ok` 124 | and `Visitor::Value` -- by carefully short-term stashing things behind a 125 | pointer. 126 | - We need to support trait methods that have a generic type in the return type 127 | but none of the argument types, like `SeqAccess::next_element` -- this can be 128 | flipped around into a callback style where the return value is instead passed 129 | on to a generic argument. 130 | 131 | In the future maybe the Rust compiler will be able to apply this technique 132 | automatically to any trait that is not already object safe by the current rules. 133 | 134 |
135 | 136 | #### License 137 | 138 | 139 | Licensed under either of Apache License, Version 140 | 2.0 or MIT license at your option. 141 | 142 | 143 |
144 | 145 | 146 | Unless you explicitly state otherwise, any contribution intentionally submitted 147 | for inclusion in this crate by you, as defined in the Apache-2.0 license, shall 148 | be dual licensed as above, without any additional terms or conditions. 149 | 150 | -------------------------------------------------------------------------------- /src/error.rs: -------------------------------------------------------------------------------- 1 | use alloc::borrow::ToOwned; 2 | use alloc::boxed::Box; 3 | use alloc::string::{String, ToString}; 4 | use alloc::vec::Vec; 5 | use core::fmt::{self, Debug, Display}; 6 | use serde::de::Expected; 7 | 8 | /// Error when a `Serializer` or `Deserializer` trait object fails. 9 | pub struct Error { 10 | imp: Box, 11 | } 12 | 13 | /// Result type alias where the error is `erased_serde::Error`. 14 | pub type Result = core::result::Result; 15 | 16 | pub(crate) fn erase_de(e: E) -> Error { 17 | serde::de::Error::custom(e) 18 | } 19 | 20 | pub(crate) fn unerase_de(e: Error) -> E { 21 | e.as_serde_de_error() 22 | } 23 | 24 | impl Display for Error { 25 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 26 | let error = self.as_serde_de_error::(); 27 | Display::fmt(&error, formatter) 28 | } 29 | } 30 | 31 | impl Debug for Error { 32 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 33 | let error = self.as_serde_de_error::(); 34 | Debug::fmt(&error, formatter) 35 | } 36 | } 37 | 38 | impl serde::ser::StdError for Error {} 39 | 40 | enum ErrorImpl { 41 | Custom(String), 42 | InvalidType { 43 | unexpected: Unexpected, 44 | expected: String, 45 | }, 46 | InvalidValue { 47 | unexpected: Unexpected, 48 | expected: String, 49 | }, 50 | InvalidLength { 51 | len: usize, 52 | expected: String, 53 | }, 54 | UnknownVariant { 55 | variant: String, 56 | expected: &'static [&'static str], 57 | }, 58 | UnknownField { 59 | field: String, 60 | expected: &'static [&'static str], 61 | }, 62 | MissingField { 63 | field: &'static str, 64 | }, 65 | DuplicateField { 66 | field: &'static str, 67 | }, 68 | } 69 | 70 | enum Unexpected { 71 | Bool(bool), 72 | Unsigned(u64), 73 | Signed(i64), 74 | Float(f64), 75 | Char(char), 76 | Str(String), 77 | Bytes(Vec), 78 | Unit, 79 | Option, 80 | NewtypeStruct, 81 | Seq, 82 | Map, 83 | Enum, 84 | UnitVariant, 85 | NewtypeVariant, 86 | TupleVariant, 87 | StructVariant, 88 | Other(String), 89 | } 90 | 91 | impl serde::ser::Error for Error { 92 | fn custom(msg: T) -> Self { 93 | let imp = Box::new(ErrorImpl::Custom(msg.to_string())); 94 | Error { imp } 95 | } 96 | } 97 | 98 | impl serde::de::Error for Error { 99 | fn custom(msg: T) -> Self { 100 | let imp = Box::new(ErrorImpl::Custom(msg.to_string())); 101 | Error { imp } 102 | } 103 | 104 | fn invalid_type(unexpected: serde::de::Unexpected, expected: &dyn Expected) -> Self { 105 | let imp = Box::new(ErrorImpl::InvalidType { 106 | unexpected: Unexpected::from_serde(unexpected), 107 | expected: expected.to_string(), 108 | }); 109 | Error { imp } 110 | } 111 | 112 | fn invalid_value(unexpected: serde::de::Unexpected, expected: &dyn Expected) -> Self { 113 | let imp = Box::new(ErrorImpl::InvalidValue { 114 | unexpected: Unexpected::from_serde(unexpected), 115 | expected: expected.to_string(), 116 | }); 117 | Error { imp } 118 | } 119 | 120 | fn invalid_length(len: usize, expected: &dyn Expected) -> Self { 121 | let imp = Box::new(ErrorImpl::InvalidLength { 122 | len, 123 | expected: expected.to_string(), 124 | }); 125 | Error { imp } 126 | } 127 | 128 | fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self { 129 | let imp = Box::new(ErrorImpl::UnknownVariant { 130 | variant: variant.to_owned(), 131 | expected, 132 | }); 133 | Error { imp } 134 | } 135 | 136 | fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self { 137 | let imp = Box::new(ErrorImpl::UnknownField { 138 | field: field.to_owned(), 139 | expected, 140 | }); 141 | Error { imp } 142 | } 143 | 144 | fn missing_field(field: &'static str) -> Self { 145 | let imp = Box::new(ErrorImpl::MissingField { field }); 146 | Error { imp } 147 | } 148 | 149 | fn duplicate_field(field: &'static str) -> Self { 150 | let imp = Box::new(ErrorImpl::DuplicateField { field }); 151 | Error { imp } 152 | } 153 | } 154 | 155 | impl Error { 156 | fn as_serde_de_error(&self) -> E { 157 | match self.imp.as_ref() { 158 | ErrorImpl::Custom(msg) => E::custom(msg), 159 | ErrorImpl::InvalidType { 160 | unexpected, 161 | expected, 162 | } => E::invalid_type(unexpected.as_serde(), &expected.as_str()), 163 | ErrorImpl::InvalidValue { 164 | unexpected, 165 | expected, 166 | } => E::invalid_value(unexpected.as_serde(), &expected.as_str()), 167 | ErrorImpl::InvalidLength { len, expected } => { 168 | E::invalid_length(*len, &expected.as_str()) 169 | } 170 | ErrorImpl::UnknownVariant { variant, expected } => { 171 | E::unknown_variant(variant, expected) 172 | } 173 | ErrorImpl::UnknownField { field, expected } => E::unknown_field(field, expected), 174 | ErrorImpl::MissingField { field } => E::missing_field(field), 175 | ErrorImpl::DuplicateField { field } => E::duplicate_field(field), 176 | } 177 | } 178 | } 179 | 180 | impl Unexpected { 181 | fn from_serde(unexpected: serde::de::Unexpected) -> Self { 182 | match unexpected { 183 | serde::de::Unexpected::Bool(value) => Unexpected::Bool(value), 184 | serde::de::Unexpected::Unsigned(value) => Unexpected::Unsigned(value), 185 | serde::de::Unexpected::Signed(value) => Unexpected::Signed(value), 186 | serde::de::Unexpected::Float(value) => Unexpected::Float(value), 187 | serde::de::Unexpected::Char(value) => Unexpected::Char(value), 188 | serde::de::Unexpected::Str(value) => Unexpected::Str(value.to_owned()), 189 | serde::de::Unexpected::Bytes(value) => Unexpected::Bytes(value.to_owned()), 190 | serde::de::Unexpected::Unit => Unexpected::Unit, 191 | serde::de::Unexpected::Option => Unexpected::Option, 192 | serde::de::Unexpected::NewtypeStruct => Unexpected::NewtypeStruct, 193 | serde::de::Unexpected::Seq => Unexpected::Seq, 194 | serde::de::Unexpected::Map => Unexpected::Map, 195 | serde::de::Unexpected::Enum => Unexpected::Enum, 196 | serde::de::Unexpected::UnitVariant => Unexpected::UnitVariant, 197 | serde::de::Unexpected::NewtypeVariant => Unexpected::NewtypeVariant, 198 | serde::de::Unexpected::TupleVariant => Unexpected::TupleVariant, 199 | serde::de::Unexpected::StructVariant => Unexpected::StructVariant, 200 | serde::de::Unexpected::Other(msg) => Unexpected::Other(msg.to_owned()), 201 | } 202 | } 203 | 204 | fn as_serde(&self) -> serde::de::Unexpected { 205 | match self { 206 | Unexpected::Bool(value) => serde::de::Unexpected::Bool(*value), 207 | Unexpected::Unsigned(value) => serde::de::Unexpected::Unsigned(*value), 208 | Unexpected::Signed(value) => serde::de::Unexpected::Signed(*value), 209 | Unexpected::Float(value) => serde::de::Unexpected::Float(*value), 210 | Unexpected::Char(value) => serde::de::Unexpected::Char(*value), 211 | Unexpected::Str(value) => serde::de::Unexpected::Str(value), 212 | Unexpected::Bytes(value) => serde::de::Unexpected::Bytes(value), 213 | Unexpected::Unit => serde::de::Unexpected::Unit, 214 | Unexpected::Option => serde::de::Unexpected::Option, 215 | Unexpected::NewtypeStruct => serde::de::Unexpected::NewtypeStruct, 216 | Unexpected::Seq => serde::de::Unexpected::Seq, 217 | Unexpected::Map => serde::de::Unexpected::Map, 218 | Unexpected::Enum => serde::de::Unexpected::Enum, 219 | Unexpected::UnitVariant => serde::de::Unexpected::UnitVariant, 220 | Unexpected::NewtypeVariant => serde::de::Unexpected::NewtypeVariant, 221 | Unexpected::TupleVariant => serde::de::Unexpected::TupleVariant, 222 | Unexpected::StructVariant => serde::de::Unexpected::StructVariant, 223 | Unexpected::Other(msg) => serde::de::Unexpected::Other(msg), 224 | } 225 | } 226 | } 227 | -------------------------------------------------------------------------------- /LICENSE-APACHE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | -------------------------------------------------------------------------------- /src/ser.rs: -------------------------------------------------------------------------------- 1 | use self::ErrorImpl::ShortCircuit; 2 | use crate::error::Error; 3 | use crate::sealed; 4 | use alloc::boxed::Box; 5 | use alloc::string::{String, ToString}; 6 | use core::fmt::{self, Debug, Display}; 7 | use serde::ser::{ 8 | SerializeMap as _, SerializeSeq as _, SerializeStruct as _, SerializeStructVariant as _, 9 | SerializeTuple as _, SerializeTupleStruct as _, SerializeTupleVariant as _, 10 | }; 11 | 12 | // TRAITS ////////////////////////////////////////////////////////////////////// 13 | 14 | /// An object-safe equivalent of Serde's `Serialize` trait. 15 | /// 16 | /// Any implementation of Serde's `Serialize` converts seamlessly to a 17 | /// `&dyn erased_serde::Serialize` or `Box` trait 18 | /// object. 19 | /// 20 | /// ```rust 21 | /// use erased_serde::{Serialize, Serializer}; 22 | /// use std::collections::BTreeMap as Map; 23 | /// use std::io; 24 | /// 25 | /// fn main() { 26 | /// // Construct some serializers. 27 | /// let json = &mut serde_json::Serializer::new(io::stdout()); 28 | /// let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout())); 29 | /// 30 | /// // The values in this map are boxed trait objects. Ordinarily this would not 31 | /// // be possible with serde::Serializer because of object safety, but type 32 | /// // erasure makes it possible with erased_serde::Serializer. 33 | /// let mut formats: Map<&str, Box> = Map::new(); 34 | /// formats.insert("json", Box::new(::erase(json))); 35 | /// formats.insert("cbor", Box::new(::erase(cbor))); 36 | /// 37 | /// // These are boxed trait objects as well. Same thing here - type erasure 38 | /// // makes this possible. 39 | /// let mut values: Map<&str, Box> = Map::new(); 40 | /// values.insert("vec", Box::new(vec!["a", "b"])); 41 | /// values.insert("int", Box::new(65536)); 42 | /// 43 | /// // Pick a Serializer out of the formats map. 44 | /// let format = formats.get_mut("json").unwrap(); 45 | /// 46 | /// // Pick a Serialize out of the values map. 47 | /// let value = values.get("vec").unwrap(); 48 | /// 49 | /// // This line prints `["a","b"]` to stdout. 50 | /// value.erased_serialize(format).unwrap(); 51 | /// } 52 | /// ``` 53 | /// 54 | /// This trait is sealed and can only be implemented via a `serde::Serialize` 55 | /// impl. 56 | #[cfg_attr( 57 | not(no_diagnostic_namespace), 58 | diagnostic::on_unimplemented( 59 | message = "the trait bound `{Self}: serde::Serialize` is not satisfied", 60 | label = "the trait `serde::Serialize` is not implemented for `{Self}`, so it does not implement `erased_serde::Serialize`", 61 | ) 62 | )] 63 | pub trait Serialize: sealed::serialize::Sealed { 64 | fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error>; 65 | 66 | #[doc(hidden)] 67 | fn do_erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), ErrorImpl>; 68 | } 69 | 70 | /// An object-safe equivalent of Serde's `Serializer` trait. 71 | /// 72 | /// Any implementation of Serde's `Serializer` can be converted to a 73 | /// `&dyn erased_serde::Serializer` or `Box` trait 74 | /// object using `erased_serde::Serializer::erase`. 75 | /// 76 | /// ```rust 77 | /// use erased_serde::{Serialize, Serializer}; 78 | /// use std::collections::BTreeMap as Map; 79 | /// use std::io; 80 | /// 81 | /// fn main() { 82 | /// // Construct some serializers. 83 | /// let json = &mut serde_json::Serializer::new(io::stdout()); 84 | /// let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout())); 85 | /// 86 | /// // The values in this map are boxed trait objects. Ordinarily this would not 87 | /// // be possible with serde::Serializer because of object safety, but type 88 | /// // erasure makes it possible with erased_serde::Serializer. 89 | /// let mut formats: Map<&str, Box> = Map::new(); 90 | /// formats.insert("json", Box::new(::erase(json))); 91 | /// formats.insert("cbor", Box::new(::erase(cbor))); 92 | /// 93 | /// // These are boxed trait objects as well. Same thing here - type erasure 94 | /// // makes this possible. 95 | /// let mut values: Map<&str, Box> = Map::new(); 96 | /// values.insert("vec", Box::new(vec!["a", "b"])); 97 | /// values.insert("int", Box::new(65536)); 98 | /// 99 | /// // Pick a Serializer out of the formats map. 100 | /// let format = formats.get_mut("json").unwrap(); 101 | /// 102 | /// // Pick a Serialize out of the values map. 103 | /// let value = values.get("vec").unwrap(); 104 | /// 105 | /// // This line prints `["a","b"]` to stdout. 106 | /// value.erased_serialize(format).unwrap(); 107 | /// } 108 | /// ``` 109 | /// 110 | /// This trait is sealed and can only be implemented via a `serde::Serializer` 111 | /// impl. 112 | pub trait Serializer: sealed::serializer::Sealed { 113 | fn erased_serialize_bool(&mut self, v: bool); 114 | fn erased_serialize_i8(&mut self, v: i8); 115 | fn erased_serialize_i16(&mut self, v: i16); 116 | fn erased_serialize_i32(&mut self, v: i32); 117 | fn erased_serialize_i64(&mut self, v: i64); 118 | fn erased_serialize_i128(&mut self, v: i128); 119 | fn erased_serialize_u8(&mut self, v: u8); 120 | fn erased_serialize_u16(&mut self, v: u16); 121 | fn erased_serialize_u32(&mut self, v: u32); 122 | fn erased_serialize_u64(&mut self, v: u64); 123 | fn erased_serialize_u128(&mut self, v: u128); 124 | fn erased_serialize_f32(&mut self, v: f32); 125 | fn erased_serialize_f64(&mut self, v: f64); 126 | fn erased_serialize_char(&mut self, v: char); 127 | fn erased_serialize_str(&mut self, v: &str); 128 | fn erased_serialize_bytes(&mut self, v: &[u8]); 129 | fn erased_serialize_none(&mut self); 130 | fn erased_serialize_some(&mut self, value: &dyn Serialize); 131 | fn erased_serialize_unit(&mut self); 132 | fn erased_serialize_unit_struct(&mut self, name: &'static str); 133 | fn erased_serialize_unit_variant( 134 | &mut self, 135 | name: &'static str, 136 | variant_index: u32, 137 | variant: &'static str, 138 | ); 139 | fn erased_serialize_newtype_struct(&mut self, name: &'static str, value: &dyn Serialize); 140 | fn erased_serialize_newtype_variant( 141 | &mut self, 142 | name: &'static str, 143 | variant_index: u32, 144 | variant: &'static str, 145 | value: &dyn Serialize, 146 | ); 147 | fn erased_serialize_seq( 148 | &mut self, 149 | len: Option, 150 | ) -> Result<&mut dyn SerializeSeq, ErrorImpl>; 151 | fn erased_serialize_tuple(&mut self, len: usize) -> Result<&mut dyn SerializeTuple, ErrorImpl>; 152 | fn erased_serialize_tuple_struct( 153 | &mut self, 154 | name: &'static str, 155 | len: usize, 156 | ) -> Result<&mut dyn SerializeTupleStruct, ErrorImpl>; 157 | fn erased_serialize_tuple_variant( 158 | &mut self, 159 | name: &'static str, 160 | variant_index: u32, 161 | variant: &'static str, 162 | len: usize, 163 | ) -> Result<&mut dyn SerializeTupleVariant, ErrorImpl>; 164 | fn erased_serialize_map( 165 | &mut self, 166 | len: Option, 167 | ) -> Result<&mut dyn SerializeMap, ErrorImpl>; 168 | fn erased_serialize_struct( 169 | &mut self, 170 | name: &'static str, 171 | len: usize, 172 | ) -> Result<&mut dyn SerializeStruct, ErrorImpl>; 173 | fn erased_serialize_struct_variant( 174 | &mut self, 175 | name: &'static str, 176 | variant_index: u32, 177 | variant: &'static str, 178 | len: usize, 179 | ) -> Result<&mut dyn SerializeStructVariant, ErrorImpl>; 180 | fn erased_is_human_readable(&self) -> bool; 181 | #[doc(hidden)] 182 | fn erased_display_error(&self) -> &dyn Display; 183 | } 184 | 185 | impl dyn Serializer { 186 | return_impl_trait! { 187 | /// Convert any Serde `Serializer` to a trait object. 188 | /// 189 | /// ```rust 190 | /// use erased_serde::{Serialize, Serializer}; 191 | /// use std::collections::BTreeMap as Map; 192 | /// use std::io; 193 | /// 194 | /// fn main() { 195 | /// // Construct some serializers. 196 | /// let json = &mut serde_json::Serializer::new(io::stdout()); 197 | /// let cbor = &mut serde_cbor::Serializer::new(serde_cbor::ser::IoWrite::new(io::stdout())); 198 | /// 199 | /// // The values in this map are boxed trait objects. Ordinarily this would not 200 | /// // be possible with serde::Serializer because of object safety, but type 201 | /// // erasure makes it possible with erased_serde::Serializer. 202 | /// let mut formats: Map<&str, Box> = Map::new(); 203 | /// formats.insert("json", Box::new(::erase(json))); 204 | /// formats.insert("cbor", Box::new(::erase(cbor))); 205 | /// 206 | /// // These are boxed trait objects as well. Same thing here - type erasure 207 | /// // makes this possible. 208 | /// let mut values: Map<&str, Box> = Map::new(); 209 | /// values.insert("vec", Box::new(vec!["a", "b"])); 210 | /// values.insert("int", Box::new(65536)); 211 | /// 212 | /// // Pick a Serializer out of the formats map. 213 | /// let format = formats.get_mut("json").unwrap(); 214 | /// 215 | /// // Pick a Serialize out of the values map. 216 | /// let value = values.get("vec").unwrap(); 217 | /// 218 | /// // This line prints `["a","b"]` to stdout. 219 | /// value.erased_serialize(format).unwrap(); 220 | /// } 221 | /// ``` 222 | pub fn erase(serializer: S) -> impl Serializer [erase::Serializer] 223 | where 224 | S: serde::Serializer, 225 | { 226 | erase::Serializer::new(serializer) 227 | } 228 | } 229 | } 230 | 231 | // IMPL ERASED SERDE FOR SERDE ///////////////////////////////////////////////// 232 | 233 | impl Serialize for T 234 | where 235 | T: ?Sized + serde::Serialize, 236 | { 237 | fn erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), Error> { 238 | match self.do_erased_serialize(serializer) { 239 | Ok(()) => Ok(()), 240 | Err(ShortCircuit) => Err(serde::ser::Error::custom(serializer.erased_display_error())), 241 | Err(ErrorImpl::Custom(msg)) => Err(serde::ser::Error::custom(msg)), 242 | } 243 | } 244 | 245 | fn do_erased_serialize(&self, serializer: &mut dyn Serializer) -> Result<(), ErrorImpl> { 246 | self.serialize(MakeSerializer(serializer)) 247 | } 248 | } 249 | 250 | impl sealed::serialize::Sealed for T where T: ?Sized + serde::Serialize {} 251 | 252 | mod erase { 253 | use core::mem; 254 | 255 | pub enum Serializer 256 | where 257 | S: serde::Serializer, 258 | { 259 | Ready(S), 260 | Seq(S::SerializeSeq), 261 | Tuple(S::SerializeTuple), 262 | TupleStruct(S::SerializeTupleStruct), 263 | TupleVariant(S::SerializeTupleVariant), 264 | Map(S::SerializeMap), 265 | Struct(S::SerializeStruct), 266 | StructVariant(S::SerializeStructVariant), 267 | Error(S::Error), 268 | Complete(S::Ok), 269 | Unusable, 270 | } 271 | 272 | impl Serializer 273 | where 274 | S: serde::Serializer, 275 | { 276 | pub(crate) fn new(serializer: S) -> Self { 277 | Serializer::Ready(serializer) 278 | } 279 | 280 | pub(crate) fn take(&mut self) -> Self { 281 | mem::replace(self, Serializer::Unusable) 282 | } 283 | 284 | pub(crate) fn take_serializer(&mut self) -> S { 285 | match self.take() { 286 | Serializer::Ready(serializer) => serializer, 287 | _ => unreachable!(), 288 | } 289 | } 290 | } 291 | } 292 | 293 | impl Serializer for erase::Serializer 294 | where 295 | T: serde::Serializer, 296 | { 297 | fn erased_serialize_bool(&mut self, v: bool) { 298 | *self = match self.take_serializer().serialize_bool(v) { 299 | Ok(ok) => erase::Serializer::Complete(ok), 300 | Err(err) => erase::Serializer::Error(err), 301 | }; 302 | } 303 | 304 | fn erased_serialize_i8(&mut self, v: i8) { 305 | *self = match self.take_serializer().serialize_i8(v) { 306 | Ok(ok) => erase::Serializer::Complete(ok), 307 | Err(err) => erase::Serializer::Error(err), 308 | }; 309 | } 310 | 311 | fn erased_serialize_i16(&mut self, v: i16) { 312 | *self = match self.take_serializer().serialize_i16(v) { 313 | Ok(ok) => erase::Serializer::Complete(ok), 314 | Err(err) => erase::Serializer::Error(err), 315 | }; 316 | } 317 | 318 | fn erased_serialize_i32(&mut self, v: i32) { 319 | *self = match self.take_serializer().serialize_i32(v) { 320 | Ok(ok) => erase::Serializer::Complete(ok), 321 | Err(err) => erase::Serializer::Error(err), 322 | }; 323 | } 324 | 325 | fn erased_serialize_i64(&mut self, v: i64) { 326 | *self = match self.take_serializer().serialize_i64(v) { 327 | Ok(ok) => erase::Serializer::Complete(ok), 328 | Err(err) => erase::Serializer::Error(err), 329 | }; 330 | } 331 | 332 | fn erased_serialize_i128(&mut self, v: i128) { 333 | *self = match self.take_serializer().serialize_i128(v) { 334 | Ok(ok) => erase::Serializer::Complete(ok), 335 | Err(err) => erase::Serializer::Error(err), 336 | }; 337 | } 338 | 339 | fn erased_serialize_u8(&mut self, v: u8) { 340 | *self = match self.take_serializer().serialize_u8(v) { 341 | Ok(ok) => erase::Serializer::Complete(ok), 342 | Err(err) => erase::Serializer::Error(err), 343 | }; 344 | } 345 | 346 | fn erased_serialize_u16(&mut self, v: u16) { 347 | *self = match self.take_serializer().serialize_u16(v) { 348 | Ok(ok) => erase::Serializer::Complete(ok), 349 | Err(err) => erase::Serializer::Error(err), 350 | }; 351 | } 352 | 353 | fn erased_serialize_u32(&mut self, v: u32) { 354 | *self = match self.take_serializer().serialize_u32(v) { 355 | Ok(ok) => erase::Serializer::Complete(ok), 356 | Err(err) => erase::Serializer::Error(err), 357 | }; 358 | } 359 | 360 | fn erased_serialize_u64(&mut self, v: u64) { 361 | *self = match self.take_serializer().serialize_u64(v) { 362 | Ok(ok) => erase::Serializer::Complete(ok), 363 | Err(err) => erase::Serializer::Error(err), 364 | }; 365 | } 366 | 367 | fn erased_serialize_u128(&mut self, v: u128) { 368 | *self = match self.take_serializer().serialize_u128(v) { 369 | Ok(ok) => erase::Serializer::Complete(ok), 370 | Err(err) => erase::Serializer::Error(err), 371 | }; 372 | } 373 | 374 | fn erased_serialize_f32(&mut self, v: f32) { 375 | *self = match self.take_serializer().serialize_f32(v) { 376 | Ok(ok) => erase::Serializer::Complete(ok), 377 | Err(err) => erase::Serializer::Error(err), 378 | }; 379 | } 380 | 381 | fn erased_serialize_f64(&mut self, v: f64) { 382 | *self = match self.take_serializer().serialize_f64(v) { 383 | Ok(ok) => erase::Serializer::Complete(ok), 384 | Err(err) => erase::Serializer::Error(err), 385 | }; 386 | } 387 | 388 | fn erased_serialize_char(&mut self, v: char) { 389 | *self = match self.take_serializer().serialize_char(v) { 390 | Ok(ok) => erase::Serializer::Complete(ok), 391 | Err(err) => erase::Serializer::Error(err), 392 | }; 393 | } 394 | 395 | fn erased_serialize_str(&mut self, v: &str) { 396 | *self = match self.take_serializer().serialize_str(v) { 397 | Ok(ok) => erase::Serializer::Complete(ok), 398 | Err(err) => erase::Serializer::Error(err), 399 | }; 400 | } 401 | 402 | fn erased_serialize_bytes(&mut self, v: &[u8]) { 403 | *self = match self.take_serializer().serialize_bytes(v) { 404 | Ok(ok) => erase::Serializer::Complete(ok), 405 | Err(err) => erase::Serializer::Error(err), 406 | }; 407 | } 408 | 409 | fn erased_serialize_none(&mut self) { 410 | *self = match self.take_serializer().serialize_none() { 411 | Ok(ok) => erase::Serializer::Complete(ok), 412 | Err(err) => erase::Serializer::Error(err), 413 | }; 414 | } 415 | 416 | fn erased_serialize_some(&mut self, value: &dyn Serialize) { 417 | *self = match self.take_serializer().serialize_some(value) { 418 | Ok(ok) => erase::Serializer::Complete(ok), 419 | Err(err) => erase::Serializer::Error(err), 420 | }; 421 | } 422 | 423 | fn erased_serialize_unit(&mut self) { 424 | *self = match self.take_serializer().serialize_unit() { 425 | Ok(ok) => erase::Serializer::Complete(ok), 426 | Err(err) => erase::Serializer::Error(err), 427 | }; 428 | } 429 | 430 | fn erased_serialize_unit_struct(&mut self, name: &'static str) { 431 | *self = match self.take_serializer().serialize_unit_struct(name) { 432 | Ok(ok) => erase::Serializer::Complete(ok), 433 | Err(err) => erase::Serializer::Error(err), 434 | }; 435 | } 436 | 437 | fn erased_serialize_unit_variant( 438 | &mut self, 439 | name: &'static str, 440 | variant_index: u32, 441 | variant: &'static str, 442 | ) { 443 | *self = match self 444 | .take_serializer() 445 | .serialize_unit_variant(name, variant_index, variant) 446 | { 447 | Ok(ok) => erase::Serializer::Complete(ok), 448 | Err(err) => erase::Serializer::Error(err), 449 | }; 450 | } 451 | 452 | fn erased_serialize_newtype_struct(&mut self, name: &'static str, value: &dyn Serialize) { 453 | *self = match self.take_serializer().serialize_newtype_struct(name, value) { 454 | Ok(ok) => erase::Serializer::Complete(ok), 455 | Err(err) => erase::Serializer::Error(err), 456 | }; 457 | } 458 | 459 | fn erased_serialize_newtype_variant( 460 | &mut self, 461 | name: &'static str, 462 | variant_index: u32, 463 | variant: &'static str, 464 | value: &dyn Serialize, 465 | ) { 466 | *self = match self.take_serializer().serialize_newtype_variant( 467 | name, 468 | variant_index, 469 | variant, 470 | value, 471 | ) { 472 | Ok(ok) => erase::Serializer::Complete(ok), 473 | Err(err) => erase::Serializer::Error(err), 474 | }; 475 | } 476 | 477 | fn erased_serialize_seq( 478 | &mut self, 479 | len: Option, 480 | ) -> Result<&mut dyn SerializeSeq, ErrorImpl> { 481 | match self.take_serializer().serialize_seq(len) { 482 | Ok(ok) => { 483 | *self = erase::Serializer::Seq(ok); 484 | Ok(self) 485 | } 486 | Err(err) => { 487 | *self = erase::Serializer::Error(err); 488 | Err(ShortCircuit) 489 | } 490 | } 491 | } 492 | 493 | fn erased_serialize_tuple(&mut self, len: usize) -> Result<&mut dyn SerializeTuple, ErrorImpl> { 494 | match self.take_serializer().serialize_tuple(len) { 495 | Ok(ok) => { 496 | *self = erase::Serializer::Tuple(ok); 497 | Ok(self) 498 | } 499 | Err(err) => { 500 | *self = erase::Serializer::Error(err); 501 | Err(ShortCircuit) 502 | } 503 | } 504 | } 505 | 506 | fn erased_serialize_tuple_struct( 507 | &mut self, 508 | name: &'static str, 509 | len: usize, 510 | ) -> Result<&mut dyn SerializeTupleStruct, ErrorImpl> { 511 | match self.take_serializer().serialize_tuple_struct(name, len) { 512 | Ok(ok) => { 513 | *self = erase::Serializer::TupleStruct(ok); 514 | Ok(self) 515 | } 516 | Err(err) => { 517 | *self = erase::Serializer::Error(err); 518 | Err(ShortCircuit) 519 | } 520 | } 521 | } 522 | 523 | fn erased_serialize_tuple_variant( 524 | &mut self, 525 | name: &'static str, 526 | variant_index: u32, 527 | variant: &'static str, 528 | len: usize, 529 | ) -> Result<&mut dyn SerializeTupleVariant, ErrorImpl> { 530 | match self 531 | .take_serializer() 532 | .serialize_tuple_variant(name, variant_index, variant, len) 533 | { 534 | Ok(ok) => { 535 | *self = erase::Serializer::TupleVariant(ok); 536 | Ok(self) 537 | } 538 | Err(err) => { 539 | *self = erase::Serializer::Error(err); 540 | Err(ShortCircuit) 541 | } 542 | } 543 | } 544 | 545 | fn erased_serialize_map( 546 | &mut self, 547 | len: Option, 548 | ) -> Result<&mut dyn SerializeMap, ErrorImpl> { 549 | match self.take_serializer().serialize_map(len) { 550 | Ok(ok) => { 551 | *self = erase::Serializer::Map(ok); 552 | Ok(self) 553 | } 554 | Err(err) => { 555 | *self = erase::Serializer::Error(err); 556 | Err(ShortCircuit) 557 | } 558 | } 559 | } 560 | 561 | fn erased_serialize_struct( 562 | &mut self, 563 | name: &'static str, 564 | len: usize, 565 | ) -> Result<&mut dyn SerializeStruct, ErrorImpl> { 566 | match self.take_serializer().serialize_struct(name, len) { 567 | Ok(ok) => { 568 | *self = erase::Serializer::Struct(ok); 569 | Ok(self) 570 | } 571 | Err(err) => { 572 | *self = erase::Serializer::Error(err); 573 | Err(ShortCircuit) 574 | } 575 | } 576 | } 577 | 578 | fn erased_serialize_struct_variant( 579 | &mut self, 580 | name: &'static str, 581 | variant_index: u32, 582 | variant: &'static str, 583 | len: usize, 584 | ) -> Result<&mut dyn SerializeStructVariant, ErrorImpl> { 585 | match self 586 | .take_serializer() 587 | .serialize_struct_variant(name, variant_index, variant, len) 588 | { 589 | Ok(ok) => { 590 | *self = erase::Serializer::StructVariant(ok); 591 | Ok(self) 592 | } 593 | Err(err) => { 594 | *self = erase::Serializer::Error(err); 595 | Err(ShortCircuit) 596 | } 597 | } 598 | } 599 | 600 | fn erased_is_human_readable(&self) -> bool { 601 | match self { 602 | erase::Serializer::Ready(serializer) => serializer.is_human_readable(), 603 | _ => unreachable!(), 604 | } 605 | } 606 | 607 | fn erased_display_error(&self) -> &dyn Display { 608 | match self { 609 | erase::Serializer::Error(err) => err, 610 | _ => unreachable!(), 611 | } 612 | } 613 | } 614 | 615 | impl sealed::serializer::Sealed for erase::Serializer where T: serde::Serializer {} 616 | 617 | pub enum ErrorImpl { 618 | ShortCircuit, 619 | Custom(Box), 620 | } 621 | 622 | impl Display for ErrorImpl { 623 | fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result { 624 | unimplemented!() 625 | } 626 | } 627 | 628 | impl Debug for ErrorImpl { 629 | fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result { 630 | unimplemented!() 631 | } 632 | } 633 | 634 | impl serde::ser::StdError for ErrorImpl {} 635 | 636 | impl serde::ser::Error for ErrorImpl { 637 | fn custom(msg: T) -> Self { 638 | ErrorImpl::Custom(Box::new(msg.to_string())) 639 | } 640 | } 641 | 642 | // IMPL SERDE FOR ERASED SERDE ///////////////////////////////////////////////// 643 | 644 | /// Serialize the given type-erased serializable value. 645 | /// 646 | /// This can be used to implement `serde::Serialize` for trait objects that have 647 | /// `erased_serde::Serialize` as a supertrait. 648 | /// 649 | /// ``` 650 | /// trait Event: erased_serde::Serialize { 651 | /// /* ... */ 652 | /// } 653 | /// 654 | /// impl<'a> serde::Serialize for dyn Event + 'a { 655 | /// fn serialize(&self, serializer: S) -> Result 656 | /// where 657 | /// S: serde::Serializer, 658 | /// { 659 | /// erased_serde::serialize(self, serializer) 660 | /// } 661 | /// } 662 | /// ``` 663 | /// 664 | /// Since this is reasonably common, the `serialize_trait_object!` macro 665 | /// generates such a Serialize impl. 666 | /// 667 | /// ``` 668 | /// use erased_serde::serialize_trait_object; 669 | /// # 670 | /// # trait Event: erased_serde::Serialize {} 671 | /// 672 | /// serialize_trait_object!(Event); 673 | /// ``` 674 | pub fn serialize(value: &T, serializer: S) -> Result 675 | where 676 | T: ?Sized + Serialize, 677 | S: serde::Serializer, 678 | { 679 | let mut erased = erase::Serializer::new(serializer); 680 | match value.do_erased_serialize(&mut erased) { 681 | Ok(()) | Err(ShortCircuit) => {} 682 | Err(ErrorImpl::Custom(msg)) => return Err(serde::ser::Error::custom(msg)), 683 | } 684 | match erased { 685 | erase::Serializer::Complete(ok) => Ok(ok), 686 | erase::Serializer::Error(err) => Err(err), 687 | _ => unreachable!(), 688 | } 689 | } 690 | 691 | serialize_trait_object!(Serialize); 692 | 693 | struct MakeSerializer(TraitObject); 694 | 695 | impl<'a> serde::Serializer for MakeSerializer<&'a mut (dyn Serializer + '_)> { 696 | type Ok = (); 697 | type Error = ErrorImpl; 698 | type SerializeSeq = MakeSerializer<&'a mut dyn SerializeSeq>; 699 | type SerializeTuple = MakeSerializer<&'a mut dyn SerializeTuple>; 700 | type SerializeTupleStruct = MakeSerializer<&'a mut dyn SerializeTupleStruct>; 701 | type SerializeTupleVariant = MakeSerializer<&'a mut dyn SerializeTupleVariant>; 702 | type SerializeMap = MakeSerializer<&'a mut dyn SerializeMap>; 703 | type SerializeStruct = MakeSerializer<&'a mut dyn SerializeStruct>; 704 | type SerializeStructVariant = MakeSerializer<&'a mut dyn SerializeStructVariant>; 705 | 706 | fn serialize_bool(self, v: bool) -> Result { 707 | self.0.erased_serialize_bool(v); 708 | Ok(()) 709 | } 710 | 711 | fn serialize_i8(self, v: i8) -> Result { 712 | self.0.erased_serialize_i8(v); 713 | Ok(()) 714 | } 715 | 716 | fn serialize_i16(self, v: i16) -> Result { 717 | self.0.erased_serialize_i16(v); 718 | Ok(()) 719 | } 720 | 721 | fn serialize_i32(self, v: i32) -> Result { 722 | self.0.erased_serialize_i32(v); 723 | Ok(()) 724 | } 725 | 726 | fn serialize_i64(self, v: i64) -> Result { 727 | self.0.erased_serialize_i64(v); 728 | Ok(()) 729 | } 730 | 731 | fn serialize_i128(self, v: i128) -> Result { 732 | self.0.erased_serialize_i128(v); 733 | Ok(()) 734 | } 735 | 736 | fn serialize_u8(self, v: u8) -> Result { 737 | self.0.erased_serialize_u8(v); 738 | Ok(()) 739 | } 740 | 741 | fn serialize_u16(self, v: u16) -> Result { 742 | self.0.erased_serialize_u16(v); 743 | Ok(()) 744 | } 745 | 746 | fn serialize_u32(self, v: u32) -> Result { 747 | self.0.erased_serialize_u32(v); 748 | Ok(()) 749 | } 750 | 751 | fn serialize_u64(self, v: u64) -> Result { 752 | self.0.erased_serialize_u64(v); 753 | Ok(()) 754 | } 755 | 756 | fn serialize_u128(self, v: u128) -> Result { 757 | self.0.erased_serialize_u128(v); 758 | Ok(()) 759 | } 760 | 761 | fn serialize_f32(self, v: f32) -> Result { 762 | self.0.erased_serialize_f32(v); 763 | Ok(()) 764 | } 765 | 766 | fn serialize_f64(self, v: f64) -> Result { 767 | self.0.erased_serialize_f64(v); 768 | Ok(()) 769 | } 770 | 771 | fn serialize_char(self, v: char) -> Result { 772 | self.0.erased_serialize_char(v); 773 | Ok(()) 774 | } 775 | 776 | fn serialize_str(self, v: &str) -> Result { 777 | self.0.erased_serialize_str(v); 778 | Ok(()) 779 | } 780 | 781 | fn serialize_bytes(self, v: &[u8]) -> Result { 782 | self.0.erased_serialize_bytes(v); 783 | Ok(()) 784 | } 785 | 786 | fn serialize_none(self) -> Result { 787 | self.0.erased_serialize_none(); 788 | Ok(()) 789 | } 790 | 791 | fn serialize_some(self, value: &T) -> Result 792 | where 793 | T: ?Sized + serde::Serialize, 794 | { 795 | self.0.erased_serialize_some(&value); 796 | Ok(()) 797 | } 798 | 799 | fn serialize_unit(self) -> Result { 800 | self.0.erased_serialize_unit(); 801 | Ok(()) 802 | } 803 | 804 | fn serialize_unit_struct(self, name: &'static str) -> Result { 805 | self.0.erased_serialize_unit_struct(name); 806 | Ok(()) 807 | } 808 | 809 | fn serialize_unit_variant( 810 | self, 811 | name: &'static str, 812 | variant_index: u32, 813 | variant: &'static str, 814 | ) -> Result { 815 | self.0 816 | .erased_serialize_unit_variant(name, variant_index, variant); 817 | Ok(()) 818 | } 819 | 820 | fn serialize_newtype_struct( 821 | self, 822 | name: &'static str, 823 | value: &T, 824 | ) -> Result 825 | where 826 | T: ?Sized + serde::Serialize, 827 | { 828 | self.0.erased_serialize_newtype_struct(name, &value); 829 | Ok(()) 830 | } 831 | 832 | fn serialize_newtype_variant( 833 | self, 834 | name: &'static str, 835 | variant_index: u32, 836 | variant: &'static str, 837 | value: &T, 838 | ) -> Result 839 | where 840 | T: ?Sized + serde::Serialize, 841 | { 842 | self.0 843 | .erased_serialize_newtype_variant(name, variant_index, variant, &value); 844 | Ok(()) 845 | } 846 | 847 | fn serialize_seq(self, len: Option) -> Result { 848 | self.0.erased_serialize_seq(len).map(MakeSerializer) 849 | } 850 | 851 | fn serialize_tuple(self, len: usize) -> Result { 852 | self.0.erased_serialize_tuple(len).map(MakeSerializer) 853 | } 854 | 855 | fn serialize_tuple_struct( 856 | self, 857 | name: &'static str, 858 | len: usize, 859 | ) -> Result { 860 | self.0 861 | .erased_serialize_tuple_struct(name, len) 862 | .map(MakeSerializer) 863 | } 864 | 865 | fn serialize_tuple_variant( 866 | self, 867 | name: &'static str, 868 | variant_index: u32, 869 | variant: &'static str, 870 | len: usize, 871 | ) -> Result { 872 | self.0 873 | .erased_serialize_tuple_variant(name, variant_index, variant, len) 874 | .map(MakeSerializer) 875 | } 876 | 877 | fn serialize_map(self, len: Option) -> Result { 878 | self.0.erased_serialize_map(len).map(MakeSerializer) 879 | } 880 | 881 | fn serialize_struct( 882 | self, 883 | name: &'static str, 884 | len: usize, 885 | ) -> Result { 886 | self.0 887 | .erased_serialize_struct(name, len) 888 | .map(MakeSerializer) 889 | } 890 | 891 | fn serialize_struct_variant( 892 | self, 893 | name: &'static str, 894 | variant_index: u32, 895 | variant: &'static str, 896 | len: usize, 897 | ) -> Result { 898 | self.0 899 | .erased_serialize_struct_variant(name, variant_index, variant, len) 900 | .map(MakeSerializer) 901 | } 902 | 903 | #[cfg(not(feature = "alloc"))] 904 | fn collect_str(self, value: &T) -> Result 905 | where 906 | T: ?Sized + Display, 907 | { 908 | unreachable!() 909 | } 910 | 911 | fn is_human_readable(&self) -> bool { 912 | self.0.erased_is_human_readable() 913 | } 914 | } 915 | 916 | pub trait SerializeSeq { 917 | fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>; 918 | fn erased_end(&mut self); 919 | } 920 | 921 | impl SerializeSeq for erase::Serializer 922 | where 923 | T: serde::Serializer, 924 | { 925 | fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> { 926 | let erase::Serializer::Seq(serializer) = self else { 927 | unreachable!(); 928 | }; 929 | serializer.serialize_element(value).map_err(|err| { 930 | *self = erase::Serializer::Error(err); 931 | ShortCircuit 932 | }) 933 | } 934 | 935 | fn erased_end(&mut self) { 936 | let erase::Serializer::Seq(serializer) = self.take() else { 937 | unreachable!(); 938 | }; 939 | *self = match serializer.end() { 940 | Ok(ok) => erase::Serializer::Complete(ok), 941 | Err(err) => erase::Serializer::Error(err), 942 | }; 943 | } 944 | } 945 | 946 | impl serde::ser::SerializeSeq for MakeSerializer<&mut dyn SerializeSeq> { 947 | type Ok = (); 948 | type Error = ErrorImpl; 949 | 950 | fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error> 951 | where 952 | T: ?Sized + serde::Serialize, 953 | { 954 | self.0.erased_serialize_element(&value) 955 | } 956 | 957 | fn end(self) -> Result { 958 | self.0.erased_end(); 959 | Ok(()) 960 | } 961 | } 962 | 963 | pub trait SerializeTuple { 964 | fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>; 965 | fn erased_end(&mut self); 966 | } 967 | 968 | impl SerializeTuple for erase::Serializer 969 | where 970 | T: serde::Serializer, 971 | { 972 | fn erased_serialize_element(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> { 973 | let erase::Serializer::Tuple(serializer) = self else { 974 | unreachable!(); 975 | }; 976 | serializer.serialize_element(value).map_err(|err| { 977 | *self = erase::Serializer::Error(err); 978 | ShortCircuit 979 | }) 980 | } 981 | 982 | fn erased_end(&mut self) { 983 | let erase::Serializer::Tuple(serializer) = self.take() else { 984 | unreachable!(); 985 | }; 986 | *self = match serializer.end() { 987 | Ok(ok) => erase::Serializer::Complete(ok), 988 | Err(err) => erase::Serializer::Error(err), 989 | }; 990 | } 991 | } 992 | 993 | impl serde::ser::SerializeTuple for MakeSerializer<&mut dyn SerializeTuple> { 994 | type Ok = (); 995 | type Error = ErrorImpl; 996 | 997 | fn serialize_element(&mut self, value: &T) -> Result<(), Self::Error> 998 | where 999 | T: ?Sized + serde::Serialize, 1000 | { 1001 | self.0.erased_serialize_element(&value) 1002 | } 1003 | 1004 | fn end(self) -> Result { 1005 | self.0.erased_end(); 1006 | Ok(()) 1007 | } 1008 | } 1009 | 1010 | pub trait SerializeTupleStruct { 1011 | fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>; 1012 | fn erased_end(&mut self); 1013 | } 1014 | 1015 | impl SerializeTupleStruct for erase::Serializer 1016 | where 1017 | T: serde::Serializer, 1018 | { 1019 | fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> { 1020 | let erase::Serializer::TupleStruct(serializer) = self else { 1021 | unreachable!(); 1022 | }; 1023 | serializer.serialize_field(value).map_err(|err| { 1024 | *self = erase::Serializer::Error(err); 1025 | ShortCircuit 1026 | }) 1027 | } 1028 | 1029 | fn erased_end(&mut self) { 1030 | let erase::Serializer::TupleStruct(serializer) = self.take() else { 1031 | unreachable!(); 1032 | }; 1033 | *self = match serializer.end() { 1034 | Ok(ok) => erase::Serializer::Complete(ok), 1035 | Err(err) => erase::Serializer::Error(err), 1036 | }; 1037 | } 1038 | } 1039 | 1040 | impl serde::ser::SerializeTupleStruct for MakeSerializer<&mut dyn SerializeTupleStruct> { 1041 | type Ok = (); 1042 | type Error = ErrorImpl; 1043 | 1044 | fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error> 1045 | where 1046 | T: ?Sized + serde::Serialize, 1047 | { 1048 | self.0.erased_serialize_field(&value) 1049 | } 1050 | 1051 | fn end(self) -> Result { 1052 | self.0.erased_end(); 1053 | Ok(()) 1054 | } 1055 | } 1056 | 1057 | pub trait SerializeTupleVariant { 1058 | fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>; 1059 | fn erased_end(&mut self); 1060 | } 1061 | 1062 | impl SerializeTupleVariant for erase::Serializer 1063 | where 1064 | T: serde::Serializer, 1065 | { 1066 | fn erased_serialize_field(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> { 1067 | let erase::Serializer::TupleVariant(serializer) = self else { 1068 | unreachable!(); 1069 | }; 1070 | serializer.serialize_field(value).map_err(|err| { 1071 | *self = erase::Serializer::Error(err); 1072 | ShortCircuit 1073 | }) 1074 | } 1075 | 1076 | fn erased_end(&mut self) { 1077 | let erase::Serializer::TupleVariant(serializer) = self.take() else { 1078 | unreachable!(); 1079 | }; 1080 | *self = match serializer.end() { 1081 | Ok(ok) => erase::Serializer::Complete(ok), 1082 | Err(err) => erase::Serializer::Error(err), 1083 | }; 1084 | } 1085 | } 1086 | 1087 | impl serde::ser::SerializeTupleVariant for MakeSerializer<&mut dyn SerializeTupleVariant> { 1088 | type Ok = (); 1089 | type Error = ErrorImpl; 1090 | 1091 | fn serialize_field(&mut self, value: &T) -> Result<(), Self::Error> 1092 | where 1093 | T: ?Sized + serde::Serialize, 1094 | { 1095 | self.0.erased_serialize_field(&value) 1096 | } 1097 | 1098 | fn end(self) -> Result { 1099 | self.0.erased_end(); 1100 | Ok(()) 1101 | } 1102 | } 1103 | 1104 | pub trait SerializeMap { 1105 | fn erased_serialize_key(&mut self, key: &dyn Serialize) -> Result<(), ErrorImpl>; 1106 | fn erased_serialize_value(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl>; 1107 | fn erased_serialize_entry( 1108 | &mut self, 1109 | key: &dyn Serialize, 1110 | value: &dyn Serialize, 1111 | ) -> Result<(), ErrorImpl>; 1112 | fn erased_end(&mut self); 1113 | } 1114 | 1115 | impl SerializeMap for erase::Serializer 1116 | where 1117 | T: serde::Serializer, 1118 | { 1119 | fn erased_serialize_key(&mut self, key: &dyn Serialize) -> Result<(), ErrorImpl> { 1120 | let erase::Serializer::Map(serializer) = self else { 1121 | unreachable!(); 1122 | }; 1123 | serializer.serialize_key(key).map_err(|err| { 1124 | *self = erase::Serializer::Error(err); 1125 | ShortCircuit 1126 | }) 1127 | } 1128 | 1129 | fn erased_serialize_value(&mut self, value: &dyn Serialize) -> Result<(), ErrorImpl> { 1130 | let erase::Serializer::Map(serializer) = self else { 1131 | unreachable!(); 1132 | }; 1133 | serializer.serialize_value(value).map_err(|err| { 1134 | *self = erase::Serializer::Error(err); 1135 | ShortCircuit 1136 | }) 1137 | } 1138 | 1139 | fn erased_serialize_entry( 1140 | &mut self, 1141 | key: &dyn Serialize, 1142 | value: &dyn Serialize, 1143 | ) -> Result<(), ErrorImpl> { 1144 | let erase::Serializer::Map(serializer) = self else { 1145 | unreachable!(); 1146 | }; 1147 | serializer.serialize_entry(key, value).map_err(|err| { 1148 | *self = erase::Serializer::Error(err); 1149 | ShortCircuit 1150 | }) 1151 | } 1152 | 1153 | fn erased_end(&mut self) { 1154 | let erase::Serializer::Map(serializer) = self.take() else { 1155 | unreachable!(); 1156 | }; 1157 | *self = match serializer.end() { 1158 | Ok(ok) => erase::Serializer::Complete(ok), 1159 | Err(err) => erase::Serializer::Error(err), 1160 | }; 1161 | } 1162 | } 1163 | 1164 | impl serde::ser::SerializeMap for MakeSerializer<&mut dyn SerializeMap> { 1165 | type Ok = (); 1166 | type Error = ErrorImpl; 1167 | 1168 | fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error> 1169 | where 1170 | T: ?Sized + serde::Serialize, 1171 | { 1172 | self.0.erased_serialize_key(&key) 1173 | } 1174 | 1175 | fn serialize_value(&mut self, value: &T) -> Result<(), Self::Error> 1176 | where 1177 | T: ?Sized + serde::Serialize, 1178 | { 1179 | self.0.erased_serialize_value(&value) 1180 | } 1181 | 1182 | fn serialize_entry(&mut self, key: &K, value: &V) -> Result<(), Self::Error> 1183 | where 1184 | K: ?Sized + serde::Serialize, 1185 | V: ?Sized + serde::Serialize, 1186 | { 1187 | self.0.erased_serialize_entry(&key, &value) 1188 | } 1189 | 1190 | fn end(self) -> Result { 1191 | self.0.erased_end(); 1192 | Ok(()) 1193 | } 1194 | } 1195 | 1196 | pub trait SerializeStruct { 1197 | fn erased_serialize_field( 1198 | &mut self, 1199 | key: &'static str, 1200 | value: &dyn Serialize, 1201 | ) -> Result<(), ErrorImpl>; 1202 | fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl>; 1203 | fn erased_end(&mut self); 1204 | } 1205 | 1206 | impl SerializeStruct for erase::Serializer 1207 | where 1208 | T: serde::Serializer, 1209 | { 1210 | fn erased_serialize_field( 1211 | &mut self, 1212 | key: &'static str, 1213 | value: &dyn Serialize, 1214 | ) -> Result<(), ErrorImpl> { 1215 | let erase::Serializer::Struct(serializer) = self else { 1216 | unreachable!(); 1217 | }; 1218 | serializer.serialize_field(key, value).map_err(|err| { 1219 | *self = erase::Serializer::Error(err); 1220 | ShortCircuit 1221 | }) 1222 | } 1223 | 1224 | fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl> { 1225 | let erase::Serializer::Struct(serializer) = self else { 1226 | unreachable!(); 1227 | }; 1228 | serializer.skip_field(key).map_err(|err| { 1229 | *self = erase::Serializer::Error(err); 1230 | ShortCircuit 1231 | }) 1232 | } 1233 | 1234 | fn erased_end(&mut self) { 1235 | let erase::Serializer::Struct(serializer) = self.take() else { 1236 | unreachable!(); 1237 | }; 1238 | *self = match serializer.end() { 1239 | Ok(ok) => erase::Serializer::Complete(ok), 1240 | Err(err) => erase::Serializer::Error(err), 1241 | }; 1242 | } 1243 | } 1244 | 1245 | impl serde::ser::SerializeStruct for MakeSerializer<&mut dyn SerializeStruct> { 1246 | type Ok = (); 1247 | type Error = ErrorImpl; 1248 | 1249 | fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> 1250 | where 1251 | T: ?Sized + serde::Serialize, 1252 | { 1253 | self.0.erased_serialize_field(key, &value) 1254 | } 1255 | 1256 | fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> { 1257 | self.0.erased_skip_field(key) 1258 | } 1259 | 1260 | fn end(self) -> Result { 1261 | self.0.erased_end(); 1262 | Ok(()) 1263 | } 1264 | } 1265 | 1266 | pub trait SerializeStructVariant { 1267 | fn erased_serialize_field( 1268 | &mut self, 1269 | key: &'static str, 1270 | value: &dyn Serialize, 1271 | ) -> Result<(), ErrorImpl>; 1272 | fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl>; 1273 | fn erased_end(&mut self); 1274 | } 1275 | 1276 | impl SerializeStructVariant for erase::Serializer 1277 | where 1278 | T: serde::Serializer, 1279 | { 1280 | fn erased_serialize_field( 1281 | &mut self, 1282 | key: &'static str, 1283 | value: &dyn Serialize, 1284 | ) -> Result<(), ErrorImpl> { 1285 | let erase::Serializer::StructVariant(serializer) = self else { 1286 | unreachable!(); 1287 | }; 1288 | serializer.serialize_field(key, value).map_err(|err| { 1289 | *self = erase::Serializer::Error(err); 1290 | ShortCircuit 1291 | }) 1292 | } 1293 | 1294 | fn erased_skip_field(&mut self, key: &'static str) -> Result<(), ErrorImpl> { 1295 | let erase::Serializer::Struct(serializer) = self else { 1296 | unreachable!(); 1297 | }; 1298 | serializer.skip_field(key).map_err(|err| { 1299 | *self = erase::Serializer::Error(err); 1300 | ShortCircuit 1301 | }) 1302 | } 1303 | 1304 | fn erased_end(&mut self) { 1305 | let erase::Serializer::StructVariant(serializer) = self.take() else { 1306 | unreachable!(); 1307 | }; 1308 | *self = match serializer.end() { 1309 | Ok(ok) => erase::Serializer::Complete(ok), 1310 | Err(err) => erase::Serializer::Error(err), 1311 | }; 1312 | } 1313 | } 1314 | 1315 | impl serde::ser::SerializeStructVariant for MakeSerializer<&mut dyn SerializeStructVariant> { 1316 | type Ok = (); 1317 | type Error = ErrorImpl; 1318 | 1319 | fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> 1320 | where 1321 | T: ?Sized + serde::Serialize, 1322 | { 1323 | self.0.erased_serialize_field(key, &value) 1324 | } 1325 | 1326 | fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> { 1327 | self.0.erased_skip_field(key) 1328 | } 1329 | 1330 | fn end(self) -> Result { 1331 | self.0.erased_end(); 1332 | Ok(()) 1333 | } 1334 | } 1335 | 1336 | // IMPL ERASED SERDE FOR ERASED SERDE ////////////////////////////////////////// 1337 | 1338 | macro_rules! deref_erased_serializer { 1339 | (<$T:ident> Serializer for $ty:ty $(where $($where:tt)*)?) => { 1340 | impl<$T> Serializer for $ty $(where $($where)*)? { 1341 | fn erased_serialize_bool(&mut self, v: bool) { 1342 | (**self).erased_serialize_bool(v); 1343 | } 1344 | 1345 | fn erased_serialize_i8(&mut self, v: i8) { 1346 | (**self).erased_serialize_i8(v); 1347 | } 1348 | 1349 | fn erased_serialize_i16(&mut self, v: i16) { 1350 | (**self).erased_serialize_i16(v); 1351 | } 1352 | 1353 | fn erased_serialize_i32(&mut self, v: i32) { 1354 | (**self).erased_serialize_i32(v); 1355 | } 1356 | 1357 | fn erased_serialize_i64(&mut self, v: i64) { 1358 | (**self).erased_serialize_i64(v); 1359 | } 1360 | 1361 | fn erased_serialize_i128(&mut self, v: i128) { 1362 | (**self).erased_serialize_i128(v); 1363 | } 1364 | 1365 | fn erased_serialize_u8(&mut self, v: u8) { 1366 | (**self).erased_serialize_u8(v); 1367 | } 1368 | 1369 | fn erased_serialize_u16(&mut self, v: u16) { 1370 | (**self).erased_serialize_u16(v); 1371 | } 1372 | 1373 | fn erased_serialize_u32(&mut self, v: u32) { 1374 | (**self).erased_serialize_u32(v); 1375 | } 1376 | 1377 | fn erased_serialize_u64(&mut self, v: u64) { 1378 | (**self).erased_serialize_u64(v); 1379 | } 1380 | 1381 | fn erased_serialize_u128(&mut self, v: u128) { 1382 | (**self).erased_serialize_u128(v); 1383 | } 1384 | 1385 | fn erased_serialize_f32(&mut self, v: f32) { 1386 | (**self).erased_serialize_f32(v); 1387 | } 1388 | 1389 | fn erased_serialize_f64(&mut self, v: f64) { 1390 | (**self).erased_serialize_f64(v); 1391 | } 1392 | 1393 | fn erased_serialize_char(&mut self, v: char) { 1394 | (**self).erased_serialize_char(v); 1395 | } 1396 | 1397 | fn erased_serialize_str(&mut self, v: &str) { 1398 | (**self).erased_serialize_str(v); 1399 | } 1400 | 1401 | fn erased_serialize_bytes(&mut self, v: &[u8]) { 1402 | (**self).erased_serialize_bytes(v); 1403 | } 1404 | 1405 | fn erased_serialize_none(&mut self) { 1406 | (**self).erased_serialize_none(); 1407 | } 1408 | 1409 | fn erased_serialize_some(&mut self, value: &dyn Serialize) { 1410 | (**self).erased_serialize_some(value); 1411 | } 1412 | 1413 | fn erased_serialize_unit(&mut self) { 1414 | (**self).erased_serialize_unit(); 1415 | } 1416 | 1417 | fn erased_serialize_unit_struct(&mut self, name: &'static str) { 1418 | (**self).erased_serialize_unit_struct(name); 1419 | } 1420 | 1421 | fn erased_serialize_unit_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str) { 1422 | (**self).erased_serialize_unit_variant(name, variant_index, variant); 1423 | } 1424 | 1425 | fn erased_serialize_newtype_struct(&mut self, name: &'static str, value: &dyn Serialize) { 1426 | (**self).erased_serialize_newtype_struct(name, value); 1427 | } 1428 | 1429 | fn erased_serialize_newtype_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str, value: &dyn Serialize) { 1430 | (**self).erased_serialize_newtype_variant(name, variant_index, variant, value); 1431 | } 1432 | 1433 | fn erased_serialize_seq(&mut self, len: Option) -> Result<&mut dyn SerializeSeq, ErrorImpl> { 1434 | (**self).erased_serialize_seq(len) 1435 | } 1436 | 1437 | fn erased_serialize_tuple(&mut self, len: usize) -> Result<&mut dyn SerializeTuple, ErrorImpl> { 1438 | (**self).erased_serialize_tuple(len) 1439 | } 1440 | 1441 | fn erased_serialize_tuple_struct(&mut self, name: &'static str, len: usize) -> Result<&mut dyn SerializeTupleStruct, ErrorImpl> { 1442 | (**self).erased_serialize_tuple_struct(name, len) 1443 | } 1444 | 1445 | fn erased_serialize_tuple_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<&mut dyn SerializeTupleVariant, ErrorImpl> { 1446 | (**self).erased_serialize_tuple_variant(name, variant_index, variant, len) 1447 | } 1448 | 1449 | fn erased_serialize_map(&mut self, len: Option) -> Result<&mut dyn SerializeMap, ErrorImpl> { 1450 | (**self).erased_serialize_map(len) 1451 | } 1452 | 1453 | fn erased_serialize_struct(&mut self, name: &'static str, len: usize) -> Result<&mut dyn SerializeStruct, ErrorImpl> { 1454 | (**self).erased_serialize_struct(name, len) 1455 | } 1456 | 1457 | fn erased_serialize_struct_variant(&mut self, name: &'static str, variant_index: u32, variant: &'static str, len: usize) -> Result<&mut dyn SerializeStructVariant, ErrorImpl> { 1458 | (**self).erased_serialize_struct_variant(name, variant_index, variant, len) 1459 | } 1460 | 1461 | fn erased_is_human_readable(&self) -> bool { 1462 | (**self).erased_is_human_readable() 1463 | } 1464 | 1465 | fn erased_display_error(&self) -> &dyn Display { 1466 | (**self).erased_display_error() 1467 | } 1468 | } 1469 | 1470 | impl<$T> sealed::serializer::Sealed for $ty $(where $($where)*)? {} 1471 | }; 1472 | } 1473 | 1474 | deref_erased_serializer!( Serializer for &mut T where T: ?Sized + Serializer); 1475 | deref_erased_serializer!( Serializer for Box where T: ?Sized + Serializer); 1476 | 1477 | // TEST //////////////////////////////////////////////////////////////////////// 1478 | 1479 | #[cfg(test)] 1480 | mod tests { 1481 | use super::*; 1482 | use alloc::{vec, vec::Vec}; 1483 | use serde_derive::Serialize; 1484 | 1485 | fn test_json(t: T) 1486 | where 1487 | T: serde::Serialize, 1488 | { 1489 | let expected = serde_json::to_vec(&t).unwrap(); 1490 | 1491 | // test borrowed trait object 1492 | { 1493 | let obj: &dyn Serialize = &t; 1494 | 1495 | let mut buf = Vec::new(); 1496 | 1497 | { 1498 | let mut ser = serde_json::Serializer::new(&mut buf); 1499 | let ser: &mut dyn Serializer = &mut ::erase(&mut ser); 1500 | 1501 | obj.erased_serialize(ser).unwrap(); 1502 | } 1503 | 1504 | assert_eq!(buf, expected); 1505 | } 1506 | 1507 | // test boxed trait object 1508 | { 1509 | let obj: Box = Box::new(t); 1510 | 1511 | let mut buf = Vec::new(); 1512 | 1513 | { 1514 | let mut ser = serde_json::Serializer::new(&mut buf); 1515 | let mut ser: Box = Box::new(::erase(&mut ser)); 1516 | 1517 | obj.erased_serialize(&mut ser).unwrap(); 1518 | } 1519 | 1520 | assert_eq!(buf, expected); 1521 | } 1522 | } 1523 | 1524 | #[test] 1525 | fn test_vec() { 1526 | test_json(vec!["a", "b"]); 1527 | } 1528 | 1529 | #[test] 1530 | fn test_struct() { 1531 | #[derive(Serialize)] 1532 | struct S { 1533 | f: usize, 1534 | } 1535 | 1536 | test_json(S { f: 256 }); 1537 | } 1538 | 1539 | #[test] 1540 | fn test_enum() { 1541 | #[derive(Serialize)] 1542 | enum E { 1543 | Unit, 1544 | Newtype(bool), 1545 | Tuple(bool, bool), 1546 | Struct { t: bool, f: bool }, 1547 | } 1548 | 1549 | test_json(E::Unit); 1550 | test_json(E::Newtype(true)); 1551 | test_json(E::Tuple(true, false)); 1552 | test_json(E::Struct { t: true, f: false }); 1553 | } 1554 | 1555 | #[test] 1556 | fn test_error_custom() { 1557 | struct Kaboom; 1558 | 1559 | impl serde::Serialize for Kaboom { 1560 | fn serialize(&self, _: S) -> Result 1561 | where 1562 | S: serde::Serializer, 1563 | { 1564 | use serde::ser::Error as _; 1565 | 1566 | Err(S::Error::custom("kaboom")) 1567 | } 1568 | } 1569 | 1570 | let obj: &dyn Serialize = &Kaboom; 1571 | 1572 | let err = serde_json::to_vec(obj).unwrap_err(); 1573 | assert_eq!(err.to_string(), "kaboom"); 1574 | } 1575 | 1576 | #[test] 1577 | fn assert_serialize() { 1578 | fn assert() {} 1579 | 1580 | assert::<&dyn Serialize>(); 1581 | assert::<&(dyn Serialize + Send)>(); 1582 | assert::<&(dyn Serialize + Sync)>(); 1583 | assert::<&(dyn Serialize + Send + Sync)>(); 1584 | assert::<&(dyn Serialize + Sync + Send)>(); 1585 | assert::>(); 1586 | assert::>(); 1587 | 1588 | assert::>(); 1589 | assert::>(); 1590 | assert::>(); 1591 | assert::>(); 1592 | assert::>(); 1593 | assert::>>(); 1594 | assert::>>(); 1595 | } 1596 | 1597 | #[test] 1598 | fn test_dangle() { 1599 | let mut json_serializer = serde_json::Serializer::new(Vec::new()); 1600 | let _erased_serializer = ::erase(&mut json_serializer); 1601 | drop(json_serializer); 1602 | } 1603 | } 1604 | -------------------------------------------------------------------------------- /src/de.rs: -------------------------------------------------------------------------------- 1 | use crate::any::Any; 2 | use crate::error::{erase_de as erase, unerase_de as unerase, Error}; 3 | use crate::map::{OptionExt, ResultExt}; 4 | use crate::sealed::deserializer::Sealed; 5 | use alloc::boxed::Box; 6 | #[cfg(feature = "alloc")] 7 | use alloc::string::String; 8 | #[cfg(feature = "alloc")] 9 | use alloc::vec::Vec; 10 | use core::fmt; 11 | 12 | /// Deserialize a value of type `T` from the given trait object. 13 | /// 14 | /// ```rust 15 | /// use erased_serde::Deserializer; 16 | /// use std::collections::BTreeMap as Map; 17 | /// 18 | /// fn main() { 19 | /// static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#; 20 | /// static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66]; 21 | /// 22 | /// // Construct some deserializers. 23 | /// let json = &mut serde_json::Deserializer::from_slice(JSON); 24 | /// let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR); 25 | /// 26 | /// // The values in this map are boxed trait objects, which is not possible 27 | /// // with the normal serde::Deserializer because of object safety. 28 | /// let mut formats: Map<&str, Box> = Map::new(); 29 | /// formats.insert("json", Box::new(::erase(json))); 30 | /// formats.insert("cbor", Box::new(::erase(cbor))); 31 | /// 32 | /// // Pick a Deserializer out of the formats map. 33 | /// let format = formats.get_mut("json").unwrap(); 34 | /// 35 | /// let data: Map = erased_serde::deserialize(format).unwrap(); 36 | /// 37 | /// println!("{}", data["A"] + data["B"]); 38 | /// } 39 | /// ``` 40 | pub fn deserialize<'de, T>(deserializer: &mut dyn Deserializer<'de>) -> Result 41 | where 42 | T: serde::Deserialize<'de>, 43 | { 44 | serde::Deserialize::deserialize(deserializer) 45 | } 46 | 47 | // TRAITS ////////////////////////////////////////////////////////////////////// 48 | 49 | pub trait DeserializeSeed<'de> { 50 | fn erased_deserialize_seed( 51 | &mut self, 52 | deserializer: &mut dyn Deserializer<'de>, 53 | ) -> Result; 54 | } 55 | 56 | /// An object-safe equivalent of Serde's `Deserializer` trait. 57 | /// 58 | /// Any implementation of Serde's `Deserializer` can be converted to a 59 | /// `&dyn erased_serde::Deserializer` or `Box` 60 | /// trait object using `erased_serde::Deserializer::erase`. 61 | /// 62 | /// ```rust 63 | /// use erased_serde::Deserializer; 64 | /// use std::collections::BTreeMap as Map; 65 | /// 66 | /// fn main() { 67 | /// static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#; 68 | /// static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66]; 69 | /// 70 | /// // Construct some deserializers. 71 | /// let json = &mut serde_json::Deserializer::from_slice(JSON); 72 | /// let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR); 73 | /// 74 | /// // The values in this map are boxed trait objects, which is not possible 75 | /// // with the normal serde::Deserializer because of object safety. 76 | /// let mut formats: Map<&str, Box> = Map::new(); 77 | /// formats.insert("json", Box::new(::erase(json))); 78 | /// formats.insert("cbor", Box::new(::erase(cbor))); 79 | /// 80 | /// // Pick a Deserializer out of the formats map. 81 | /// let format = formats.get_mut("json").unwrap(); 82 | /// 83 | /// let data: Map = erased_serde::deserialize(format).unwrap(); 84 | /// 85 | /// println!("{}", data["A"] + data["B"]); 86 | /// } 87 | /// ``` 88 | /// 89 | /// This trait is sealed and can only be implemented via a 90 | /// `serde::Deserializer<'de>` impl. 91 | pub trait Deserializer<'de>: Sealed { 92 | fn erased_deserialize_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 93 | fn erased_deserialize_bool(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 94 | fn erased_deserialize_i8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 95 | fn erased_deserialize_i16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 96 | fn erased_deserialize_i32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 97 | fn erased_deserialize_i64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 98 | fn erased_deserialize_i128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 99 | fn erased_deserialize_u8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 100 | fn erased_deserialize_u16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 101 | fn erased_deserialize_u32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 102 | fn erased_deserialize_u64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 103 | fn erased_deserialize_u128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 104 | fn erased_deserialize_f32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 105 | fn erased_deserialize_f64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 106 | fn erased_deserialize_char(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 107 | fn erased_deserialize_str(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 108 | fn erased_deserialize_string(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 109 | fn erased_deserialize_bytes(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 110 | fn erased_deserialize_byte_buf(&mut self, visitor: &mut dyn Visitor<'de>) 111 | -> Result; 112 | fn erased_deserialize_option(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 113 | fn erased_deserialize_unit(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 114 | fn erased_deserialize_unit_struct( 115 | &mut self, 116 | name: &'static str, 117 | visitor: &mut dyn Visitor<'de>, 118 | ) -> Result; 119 | fn erased_deserialize_newtype_struct( 120 | &mut self, 121 | name: &'static str, 122 | visitor: &mut dyn Visitor<'de>, 123 | ) -> Result; 124 | fn erased_deserialize_seq(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 125 | fn erased_deserialize_tuple( 126 | &mut self, 127 | len: usize, 128 | visitor: &mut dyn Visitor<'de>, 129 | ) -> Result; 130 | fn erased_deserialize_tuple_struct( 131 | &mut self, 132 | name: &'static str, 133 | len: usize, 134 | visitor: &mut dyn Visitor<'de>, 135 | ) -> Result; 136 | fn erased_deserialize_map(&mut self, visitor: &mut dyn Visitor<'de>) -> Result; 137 | fn erased_deserialize_struct( 138 | &mut self, 139 | name: &'static str, 140 | fields: &'static [&'static str], 141 | visitor: &mut dyn Visitor<'de>, 142 | ) -> Result; 143 | fn erased_deserialize_identifier( 144 | &mut self, 145 | visitor: &mut dyn Visitor<'de>, 146 | ) -> Result; 147 | fn erased_deserialize_enum( 148 | &mut self, 149 | name: &'static str, 150 | variants: &'static [&'static str], 151 | visitor: &mut dyn Visitor<'de>, 152 | ) -> Result; 153 | fn erased_deserialize_ignored_any( 154 | &mut self, 155 | visitor: &mut dyn Visitor<'de>, 156 | ) -> Result; 157 | fn erased_is_human_readable(&self) -> bool; 158 | } 159 | 160 | pub trait Visitor<'de> { 161 | fn erased_expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result; 162 | fn erased_visit_bool(&mut self, v: bool) -> Result; 163 | fn erased_visit_i8(&mut self, v: i8) -> Result; 164 | fn erased_visit_i16(&mut self, v: i16) -> Result; 165 | fn erased_visit_i32(&mut self, v: i32) -> Result; 166 | fn erased_visit_i64(&mut self, v: i64) -> Result; 167 | fn erased_visit_i128(&mut self, v: i128) -> Result; 168 | fn erased_visit_u8(&mut self, v: u8) -> Result; 169 | fn erased_visit_u16(&mut self, v: u16) -> Result; 170 | fn erased_visit_u32(&mut self, v: u32) -> Result; 171 | fn erased_visit_u64(&mut self, v: u64) -> Result; 172 | fn erased_visit_u128(&mut self, v: u128) -> Result; 173 | fn erased_visit_f32(&mut self, v: f32) -> Result; 174 | fn erased_visit_f64(&mut self, v: f64) -> Result; 175 | fn erased_visit_char(&mut self, v: char) -> Result; 176 | fn erased_visit_str(&mut self, v: &str) -> Result; 177 | fn erased_visit_borrowed_str(&mut self, v: &'de str) -> Result; 178 | #[cfg(feature = "alloc")] 179 | fn erased_visit_string(&mut self, v: String) -> Result; 180 | fn erased_visit_bytes(&mut self, v: &[u8]) -> Result; 181 | fn erased_visit_borrowed_bytes(&mut self, v: &'de [u8]) -> Result; 182 | #[cfg(feature = "alloc")] 183 | fn erased_visit_byte_buf(&mut self, v: Vec) -> Result; 184 | fn erased_visit_none(&mut self) -> Result; 185 | fn erased_visit_some(&mut self, deserializer: &mut dyn Deserializer<'de>) 186 | -> Result; 187 | fn erased_visit_unit(&mut self) -> Result; 188 | fn erased_visit_newtype_struct( 189 | &mut self, 190 | deserializer: &mut dyn Deserializer<'de>, 191 | ) -> Result; 192 | fn erased_visit_seq(&mut self, seq: &mut dyn SeqAccess<'de>) -> Result; 193 | fn erased_visit_map(&mut self, map: &mut dyn MapAccess<'de>) -> Result; 194 | fn erased_visit_enum(&mut self, data: &mut dyn EnumAccess<'de>) -> Result; 195 | } 196 | 197 | pub trait SeqAccess<'de> { 198 | fn erased_next_element( 199 | &mut self, 200 | seed: &mut dyn DeserializeSeed<'de>, 201 | ) -> Result, Error>; 202 | fn erased_size_hint(&self) -> Option; 203 | } 204 | 205 | pub trait MapAccess<'de> { 206 | fn erased_next_key( 207 | &mut self, 208 | seed: &mut dyn DeserializeSeed<'de>, 209 | ) -> Result, Error>; 210 | fn erased_next_value(&mut self, seed: &mut dyn DeserializeSeed<'de>) -> Result; 211 | fn erased_next_entry( 212 | &mut self, 213 | key: &mut dyn DeserializeSeed<'de>, 214 | value: &mut dyn DeserializeSeed<'de>, 215 | ) -> Result, Error>; 216 | fn erased_size_hint(&self) -> Option; 217 | } 218 | 219 | pub trait EnumAccess<'de> { 220 | fn erased_variant_seed( 221 | &mut self, 222 | seed: &mut dyn DeserializeSeed<'de>, 223 | ) -> Result<(Out, Variant<'de>), Error>; 224 | } 225 | 226 | impl<'de> dyn Deserializer<'de> { 227 | return_impl_trait! { 228 | /// Convert any Serde `Deserializer` to a trait object. 229 | /// 230 | /// ```rust 231 | /// use erased_serde::Deserializer; 232 | /// use std::collections::BTreeMap as Map; 233 | /// 234 | /// fn main() { 235 | /// static JSON: &'static [u8] = br#"{"A": 65, "B": 66}"#; 236 | /// static CBOR: &'static [u8] = &[162, 97, 65, 24, 65, 97, 66, 24, 66]; 237 | /// 238 | /// // Construct some deserializers. 239 | /// let json = &mut serde_json::Deserializer::from_slice(JSON); 240 | /// let cbor = &mut serde_cbor::Deserializer::from_slice(CBOR); 241 | /// 242 | /// // The values in this map are boxed trait objects, which is not possible 243 | /// // with the normal serde::Deserializer because of object safety. 244 | /// let mut formats: Map<&str, Box> = Map::new(); 245 | /// formats.insert("json", Box::new(::erase(json))); 246 | /// formats.insert("cbor", Box::new(::erase(cbor))); 247 | /// 248 | /// // Pick a Deserializer out of the formats map. 249 | /// let format = formats.get_mut("json").unwrap(); 250 | /// 251 | /// let data: Map = erased_serde::deserialize(format).unwrap(); 252 | /// 253 | /// println!("{}", data["A"] + data["B"]); 254 | /// } 255 | /// ``` 256 | pub fn erase(deserializer: D) -> impl Deserializer<'de> [erase::Deserializer] 257 | where 258 | D: serde::Deserializer<'de>, 259 | { 260 | erase::Deserializer::new(deserializer) 261 | } 262 | } 263 | } 264 | 265 | // OUT ///////////////////////////////////////////////////////////////////////// 266 | 267 | pub struct Out(Any); 268 | 269 | impl Out { 270 | unsafe fn new(t: T) -> Self { 271 | Out(unsafe { Any::new(t) }) 272 | } 273 | 274 | unsafe fn take(self) -> T { 275 | unsafe { self.0.take() } 276 | } 277 | } 278 | 279 | // IMPL ERASED SERDE FOR SERDE ///////////////////////////////////////////////// 280 | 281 | mod erase { 282 | pub struct DeserializeSeed { 283 | state: Option, 284 | } 285 | 286 | impl DeserializeSeed { 287 | pub(crate) fn new(seed: D) -> Self { 288 | DeserializeSeed { state: Some(seed) } 289 | } 290 | 291 | pub(crate) fn take(&mut self) -> D { 292 | self.state.take().unwrap() 293 | } 294 | } 295 | 296 | pub struct Deserializer { 297 | state: Option, 298 | } 299 | 300 | impl Deserializer { 301 | pub(crate) fn new(deserializer: D) -> Self { 302 | Deserializer { 303 | state: Some(deserializer), 304 | } 305 | } 306 | 307 | pub(crate) fn take(&mut self) -> D { 308 | self.state.take().unwrap() 309 | } 310 | 311 | pub(crate) fn as_ref(&self) -> &D { 312 | self.state.as_ref().unwrap() 313 | } 314 | } 315 | 316 | pub struct Visitor { 317 | state: Option, 318 | } 319 | 320 | impl Visitor { 321 | pub(crate) fn new(visitor: D) -> Self { 322 | Visitor { 323 | state: Some(visitor), 324 | } 325 | } 326 | 327 | pub(crate) fn take(&mut self) -> D { 328 | self.state.take().unwrap() 329 | } 330 | 331 | pub(crate) fn as_ref(&self) -> &D { 332 | self.state.as_ref().unwrap() 333 | } 334 | } 335 | 336 | pub struct SeqAccess { 337 | state: D, 338 | } 339 | 340 | impl SeqAccess { 341 | pub(crate) fn new(seq_access: D) -> Self { 342 | SeqAccess { state: seq_access } 343 | } 344 | 345 | pub(crate) fn as_ref(&self) -> &D { 346 | &self.state 347 | } 348 | 349 | pub(crate) fn as_mut(&mut self) -> &mut D { 350 | &mut self.state 351 | } 352 | } 353 | 354 | pub struct MapAccess { 355 | state: D, 356 | } 357 | 358 | impl MapAccess { 359 | pub(crate) fn new(map_access: D) -> Self { 360 | MapAccess { state: map_access } 361 | } 362 | 363 | pub(crate) fn as_ref(&self) -> &D { 364 | &self.state 365 | } 366 | 367 | pub(crate) fn as_mut(&mut self) -> &mut D { 368 | &mut self.state 369 | } 370 | } 371 | 372 | pub struct EnumAccess { 373 | state: Option, 374 | } 375 | 376 | impl EnumAccess { 377 | pub(crate) fn new(enum_access: D) -> Self { 378 | EnumAccess { 379 | state: Some(enum_access), 380 | } 381 | } 382 | 383 | pub(crate) fn take(&mut self) -> D { 384 | self.state.take().unwrap() 385 | } 386 | } 387 | } 388 | 389 | impl<'de, T> DeserializeSeed<'de> for erase::DeserializeSeed 390 | where 391 | T: serde::de::DeserializeSeed<'de>, 392 | { 393 | fn erased_deserialize_seed( 394 | &mut self, 395 | deserializer: &mut dyn Deserializer<'de>, 396 | ) -> Result { 397 | unsafe { self.take().deserialize(deserializer).unsafe_map(Out::new) } 398 | } 399 | } 400 | 401 | impl<'de, T> Deserializer<'de> for erase::Deserializer 402 | where 403 | T: serde::Deserializer<'de>, 404 | { 405 | fn erased_deserialize_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 406 | self.take().deserialize_any(visitor).map_err(erase) 407 | } 408 | 409 | fn erased_deserialize_bool(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 410 | self.take().deserialize_bool(visitor).map_err(erase) 411 | } 412 | 413 | fn erased_deserialize_i8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 414 | self.take().deserialize_i8(visitor).map_err(erase) 415 | } 416 | 417 | fn erased_deserialize_i16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 418 | self.take().deserialize_i16(visitor).map_err(erase) 419 | } 420 | 421 | fn erased_deserialize_i32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 422 | self.take().deserialize_i32(visitor).map_err(erase) 423 | } 424 | 425 | fn erased_deserialize_i64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 426 | self.take().deserialize_i64(visitor).map_err(erase) 427 | } 428 | 429 | fn erased_deserialize_i128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 430 | self.take().deserialize_i128(visitor).map_err(erase) 431 | } 432 | 433 | fn erased_deserialize_u8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 434 | self.take().deserialize_u8(visitor).map_err(erase) 435 | } 436 | 437 | fn erased_deserialize_u16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 438 | self.take().deserialize_u16(visitor).map_err(erase) 439 | } 440 | 441 | fn erased_deserialize_u32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 442 | self.take().deserialize_u32(visitor).map_err(erase) 443 | } 444 | 445 | fn erased_deserialize_u64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 446 | self.take().deserialize_u64(visitor).map_err(erase) 447 | } 448 | 449 | fn erased_deserialize_u128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 450 | self.take().deserialize_u128(visitor).map_err(erase) 451 | } 452 | 453 | fn erased_deserialize_f32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 454 | self.take().deserialize_f32(visitor).map_err(erase) 455 | } 456 | 457 | fn erased_deserialize_f64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 458 | self.take().deserialize_f64(visitor).map_err(erase) 459 | } 460 | 461 | fn erased_deserialize_char(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 462 | self.take().deserialize_char(visitor).map_err(erase) 463 | } 464 | 465 | fn erased_deserialize_str(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 466 | self.take().deserialize_str(visitor).map_err(erase) 467 | } 468 | 469 | fn erased_deserialize_string(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 470 | self.take().deserialize_string(visitor).map_err(erase) 471 | } 472 | 473 | fn erased_deserialize_bytes(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 474 | self.take().deserialize_bytes(visitor).map_err(erase) 475 | } 476 | 477 | fn erased_deserialize_byte_buf( 478 | &mut self, 479 | visitor: &mut dyn Visitor<'de>, 480 | ) -> Result { 481 | self.take().deserialize_byte_buf(visitor).map_err(erase) 482 | } 483 | 484 | fn erased_deserialize_option(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 485 | self.take().deserialize_option(visitor).map_err(erase) 486 | } 487 | 488 | fn erased_deserialize_unit(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 489 | self.take().deserialize_unit(visitor).map_err(erase) 490 | } 491 | 492 | fn erased_deserialize_unit_struct( 493 | &mut self, 494 | name: &'static str, 495 | visitor: &mut dyn Visitor<'de>, 496 | ) -> Result { 497 | self.take() 498 | .deserialize_unit_struct(name, visitor) 499 | .map_err(erase) 500 | } 501 | 502 | fn erased_deserialize_newtype_struct( 503 | &mut self, 504 | name: &'static str, 505 | visitor: &mut dyn Visitor<'de>, 506 | ) -> Result { 507 | self.take() 508 | .deserialize_newtype_struct(name, visitor) 509 | .map_err(erase) 510 | } 511 | 512 | fn erased_deserialize_seq(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 513 | self.take().deserialize_seq(visitor).map_err(erase) 514 | } 515 | 516 | fn erased_deserialize_tuple( 517 | &mut self, 518 | len: usize, 519 | visitor: &mut dyn Visitor<'de>, 520 | ) -> Result { 521 | self.take().deserialize_tuple(len, visitor).map_err(erase) 522 | } 523 | 524 | fn erased_deserialize_tuple_struct( 525 | &mut self, 526 | name: &'static str, 527 | len: usize, 528 | visitor: &mut dyn Visitor<'de>, 529 | ) -> Result { 530 | self.take() 531 | .deserialize_tuple_struct(name, len, visitor) 532 | .map_err(erase) 533 | } 534 | 535 | fn erased_deserialize_map(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 536 | self.take().deserialize_map(visitor).map_err(erase) 537 | } 538 | 539 | fn erased_deserialize_struct( 540 | &mut self, 541 | name: &'static str, 542 | fields: &'static [&'static str], 543 | visitor: &mut dyn Visitor<'de>, 544 | ) -> Result { 545 | self.take() 546 | .deserialize_struct(name, fields, visitor) 547 | .map_err(erase) 548 | } 549 | 550 | fn erased_deserialize_identifier( 551 | &mut self, 552 | visitor: &mut dyn Visitor<'de>, 553 | ) -> Result { 554 | self.take().deserialize_identifier(visitor).map_err(erase) 555 | } 556 | 557 | fn erased_deserialize_enum( 558 | &mut self, 559 | name: &'static str, 560 | variants: &'static [&'static str], 561 | visitor: &mut dyn Visitor<'de>, 562 | ) -> Result { 563 | self.take() 564 | .deserialize_enum(name, variants, visitor) 565 | .map_err(erase) 566 | } 567 | 568 | fn erased_deserialize_ignored_any( 569 | &mut self, 570 | visitor: &mut dyn Visitor<'de>, 571 | ) -> Result { 572 | self.take().deserialize_ignored_any(visitor).map_err(erase) 573 | } 574 | 575 | fn erased_is_human_readable(&self) -> bool { 576 | self.as_ref().is_human_readable() 577 | } 578 | } 579 | 580 | impl<'de, T> Sealed for erase::Deserializer where T: serde::Deserializer<'de> {} 581 | 582 | impl<'de, T> Visitor<'de> for erase::Visitor 583 | where 584 | T: serde::de::Visitor<'de>, 585 | { 586 | fn erased_expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 587 | self.as_ref().expecting(formatter) 588 | } 589 | 590 | fn erased_visit_bool(&mut self, v: bool) -> Result { 591 | unsafe { self.take().visit_bool(v).unsafe_map(Out::new) } 592 | } 593 | 594 | fn erased_visit_i8(&mut self, v: i8) -> Result { 595 | unsafe { self.take().visit_i8(v).unsafe_map(Out::new) } 596 | } 597 | 598 | fn erased_visit_i16(&mut self, v: i16) -> Result { 599 | unsafe { self.take().visit_i16(v).unsafe_map(Out::new) } 600 | } 601 | 602 | fn erased_visit_i32(&mut self, v: i32) -> Result { 603 | unsafe { self.take().visit_i32(v).unsafe_map(Out::new) } 604 | } 605 | 606 | fn erased_visit_i64(&mut self, v: i64) -> Result { 607 | unsafe { self.take().visit_i64(v).unsafe_map(Out::new) } 608 | } 609 | 610 | fn erased_visit_i128(&mut self, v: i128) -> Result { 611 | unsafe { self.take().visit_i128(v).unsafe_map(Out::new) } 612 | } 613 | 614 | fn erased_visit_u8(&mut self, v: u8) -> Result { 615 | unsafe { self.take().visit_u8(v).unsafe_map(Out::new) } 616 | } 617 | 618 | fn erased_visit_u16(&mut self, v: u16) -> Result { 619 | unsafe { self.take().visit_u16(v).unsafe_map(Out::new) } 620 | } 621 | 622 | fn erased_visit_u32(&mut self, v: u32) -> Result { 623 | unsafe { self.take().visit_u32(v).unsafe_map(Out::new) } 624 | } 625 | 626 | fn erased_visit_u64(&mut self, v: u64) -> Result { 627 | unsafe { self.take().visit_u64(v).unsafe_map(Out::new) } 628 | } 629 | 630 | fn erased_visit_u128(&mut self, v: u128) -> Result { 631 | unsafe { self.take().visit_u128(v).unsafe_map(Out::new) } 632 | } 633 | 634 | fn erased_visit_f32(&mut self, v: f32) -> Result { 635 | unsafe { self.take().visit_f32(v).unsafe_map(Out::new) } 636 | } 637 | 638 | fn erased_visit_f64(&mut self, v: f64) -> Result { 639 | unsafe { self.take().visit_f64(v).unsafe_map(Out::new) } 640 | } 641 | 642 | fn erased_visit_char(&mut self, v: char) -> Result { 643 | unsafe { self.take().visit_char(v).unsafe_map(Out::new) } 644 | } 645 | 646 | fn erased_visit_str(&mut self, v: &str) -> Result { 647 | unsafe { self.take().visit_str(v).unsafe_map(Out::new) } 648 | } 649 | 650 | fn erased_visit_borrowed_str(&mut self, v: &'de str) -> Result { 651 | unsafe { self.take().visit_borrowed_str(v).unsafe_map(Out::new) } 652 | } 653 | 654 | #[cfg(feature = "alloc")] 655 | fn erased_visit_string(&mut self, v: String) -> Result { 656 | unsafe { self.take().visit_string(v).unsafe_map(Out::new) } 657 | } 658 | 659 | fn erased_visit_bytes(&mut self, v: &[u8]) -> Result { 660 | unsafe { self.take().visit_bytes(v).unsafe_map(Out::new) } 661 | } 662 | 663 | fn erased_visit_borrowed_bytes(&mut self, v: &'de [u8]) -> Result { 664 | unsafe { self.take().visit_borrowed_bytes(v).unsafe_map(Out::new) } 665 | } 666 | 667 | #[cfg(feature = "alloc")] 668 | fn erased_visit_byte_buf(&mut self, v: Vec) -> Result { 669 | unsafe { self.take().visit_byte_buf(v).unsafe_map(Out::new) } 670 | } 671 | 672 | fn erased_visit_none(&mut self) -> Result { 673 | unsafe { self.take().visit_none().unsafe_map(Out::new) } 674 | } 675 | 676 | fn erased_visit_some( 677 | &mut self, 678 | deserializer: &mut dyn Deserializer<'de>, 679 | ) -> Result { 680 | unsafe { self.take().visit_some(deserializer).unsafe_map(Out::new) } 681 | } 682 | 683 | fn erased_visit_unit(&mut self) -> Result { 684 | unsafe { self.take().visit_unit().unsafe_map(Out::new) } 685 | } 686 | 687 | fn erased_visit_newtype_struct( 688 | &mut self, 689 | deserializer: &mut dyn Deserializer<'de>, 690 | ) -> Result { 691 | unsafe { 692 | self.take() 693 | .visit_newtype_struct(deserializer) 694 | .unsafe_map(Out::new) 695 | } 696 | } 697 | 698 | fn erased_visit_seq(&mut self, seq: &mut dyn SeqAccess<'de>) -> Result { 699 | unsafe { self.take().visit_seq(seq).unsafe_map(Out::new) } 700 | } 701 | 702 | fn erased_visit_map(&mut self, map: &mut dyn MapAccess<'de>) -> Result { 703 | unsafe { self.take().visit_map(map).unsafe_map(Out::new) } 704 | } 705 | 706 | fn erased_visit_enum(&mut self, data: &mut dyn EnumAccess<'de>) -> Result { 707 | unsafe { self.take().visit_enum(data).unsafe_map(Out::new) } 708 | } 709 | } 710 | 711 | impl<'de, T> SeqAccess<'de> for erase::SeqAccess 712 | where 713 | T: serde::de::SeqAccess<'de>, 714 | { 715 | fn erased_next_element( 716 | &mut self, 717 | seed: &mut dyn DeserializeSeed<'de>, 718 | ) -> Result, Error> { 719 | self.as_mut().next_element_seed(seed).map_err(erase) 720 | } 721 | 722 | fn erased_size_hint(&self) -> Option { 723 | self.as_ref().size_hint() 724 | } 725 | } 726 | 727 | impl<'de, T> MapAccess<'de> for erase::MapAccess 728 | where 729 | T: serde::de::MapAccess<'de>, 730 | { 731 | fn erased_next_key( 732 | &mut self, 733 | seed: &mut dyn DeserializeSeed<'de>, 734 | ) -> Result, Error> { 735 | self.as_mut().next_key_seed(seed).map_err(erase) 736 | } 737 | 738 | fn erased_next_value(&mut self, seed: &mut dyn DeserializeSeed<'de>) -> Result { 739 | self.as_mut().next_value_seed(seed).map_err(erase) 740 | } 741 | 742 | fn erased_next_entry( 743 | &mut self, 744 | kseed: &mut dyn DeserializeSeed<'de>, 745 | vseed: &mut dyn DeserializeSeed<'de>, 746 | ) -> Result, Error> { 747 | self.as_mut().next_entry_seed(kseed, vseed).map_err(erase) 748 | } 749 | 750 | fn erased_size_hint(&self) -> Option { 751 | self.as_ref().size_hint() 752 | } 753 | } 754 | 755 | impl<'de, T> EnumAccess<'de> for erase::EnumAccess 756 | where 757 | T: serde::de::EnumAccess<'de>, 758 | { 759 | fn erased_variant_seed( 760 | &mut self, 761 | seed: &mut dyn DeserializeSeed<'de>, 762 | ) -> Result<(Out, Variant<'de>), Error> { 763 | self.take() 764 | .variant_seed(seed) 765 | .map(|(out, variant)| { 766 | use serde::de::VariantAccess; 767 | let erased = Variant { 768 | data: unsafe { Any::new(variant) }, 769 | unit_variant: { 770 | unsafe fn unit_variant<'de, T>(a: Any) -> Result<(), Error> 771 | where 772 | T: serde::de::EnumAccess<'de>, 773 | { 774 | unsafe { a.take::().unit_variant().map_err(erase) } 775 | } 776 | unit_variant:: 777 | }, 778 | visit_newtype: { 779 | unsafe fn visit_newtype<'de, T>( 780 | a: Any, 781 | seed: &mut dyn DeserializeSeed<'de>, 782 | ) -> Result 783 | where 784 | T: serde::de::EnumAccess<'de>, 785 | { 786 | unsafe { 787 | a.take::() 788 | .newtype_variant_seed(seed) 789 | .map_err(erase) 790 | } 791 | } 792 | visit_newtype:: 793 | }, 794 | tuple_variant: { 795 | unsafe fn tuple_variant<'de, T>( 796 | a: Any, 797 | len: usize, 798 | visitor: &mut dyn Visitor<'de>, 799 | ) -> Result 800 | where 801 | T: serde::de::EnumAccess<'de>, 802 | { 803 | unsafe { 804 | a.take::() 805 | .tuple_variant(len, visitor) 806 | .map_err(erase) 807 | } 808 | } 809 | tuple_variant:: 810 | }, 811 | struct_variant: { 812 | unsafe fn struct_variant<'de, T>( 813 | a: Any, 814 | fields: &'static [&'static str], 815 | visitor: &mut dyn Visitor<'de>, 816 | ) -> Result 817 | where 818 | T: serde::de::EnumAccess<'de>, 819 | { 820 | unsafe { 821 | a.take::() 822 | .struct_variant(fields, visitor) 823 | .map_err(erase) 824 | } 825 | } 826 | struct_variant:: 827 | }, 828 | }; 829 | (out, erased) 830 | }) 831 | .map_err(erase) 832 | } 833 | } 834 | 835 | // IMPL SERDE FOR ERASED SERDE ///////////////////////////////////////////////// 836 | 837 | impl<'de> serde::de::DeserializeSeed<'de> for &mut (dyn DeserializeSeed<'de> + '_) { 838 | type Value = Out; 839 | fn deserialize(self, deserializer: D) -> Result 840 | where 841 | D: serde::Deserializer<'de>, 842 | { 843 | let mut erased = erase::Deserializer::new(deserializer); 844 | self.erased_deserialize_seed(&mut erased).map_err(unerase) 845 | } 846 | } 847 | 848 | macro_rules! impl_deserializer_for_trait_object { 849 | ({$($mut:tt)*} $ty:ty) => { 850 | impl<'de> serde::Deserializer<'de> for $ty { 851 | type Error = Error; 852 | 853 | fn deserialize_any($($mut)* self, visitor: V) -> Result 854 | where 855 | V: serde::de::Visitor<'de>, 856 | { 857 | let mut erased = erase::Visitor::new(visitor); 858 | unsafe { self.erased_deserialize_any(&mut erased).unsafe_map(Out::take) } 859 | } 860 | 861 | fn deserialize_bool($($mut)* self, visitor: V) -> Result 862 | where 863 | V: serde::de::Visitor<'de>, 864 | { 865 | let mut erased = erase::Visitor::new(visitor); 866 | unsafe { self.erased_deserialize_bool(&mut erased).unsafe_map(Out::take) } 867 | } 868 | 869 | fn deserialize_i8($($mut)* self, visitor: V) -> Result 870 | where 871 | V: serde::de::Visitor<'de>, 872 | { 873 | let mut erased = erase::Visitor::new(visitor); 874 | unsafe { self.erased_deserialize_i8(&mut erased).unsafe_map(Out::take) } 875 | } 876 | 877 | fn deserialize_i16($($mut)* self, visitor: V) -> Result 878 | where 879 | V: serde::de::Visitor<'de>, 880 | { 881 | let mut erased = erase::Visitor::new(visitor); 882 | unsafe { self.erased_deserialize_i16(&mut erased).unsafe_map(Out::take) } 883 | } 884 | 885 | fn deserialize_i32($($mut)* self, visitor: V) -> Result 886 | where 887 | V: serde::de::Visitor<'de>, 888 | { 889 | let mut erased = erase::Visitor::new(visitor); 890 | unsafe { self.erased_deserialize_i32(&mut erased).unsafe_map(Out::take) } 891 | } 892 | 893 | fn deserialize_i64($($mut)* self, visitor: V) -> Result 894 | where 895 | V: serde::de::Visitor<'de>, 896 | { 897 | let mut erased = erase::Visitor::new(visitor); 898 | unsafe { self.erased_deserialize_i64(&mut erased).unsafe_map(Out::take) } 899 | } 900 | 901 | fn deserialize_i128($($mut)* self, visitor: V) -> Result 902 | where 903 | V: serde::de::Visitor<'de>, 904 | { 905 | let mut erased = erase::Visitor::new(visitor); 906 | unsafe { self.erased_deserialize_i128(&mut erased).unsafe_map(Out::take) } 907 | } 908 | 909 | fn deserialize_u8($($mut)* self, visitor: V) -> Result 910 | where 911 | V: serde::de::Visitor<'de>, 912 | { 913 | let mut erased = erase::Visitor::new(visitor); 914 | unsafe { self.erased_deserialize_u8(&mut erased).unsafe_map(Out::take) } 915 | } 916 | 917 | fn deserialize_u16($($mut)* self, visitor: V) -> Result 918 | where 919 | V: serde::de::Visitor<'de>, 920 | { 921 | let mut erased = erase::Visitor::new(visitor); 922 | unsafe { self.erased_deserialize_u16(&mut erased).unsafe_map(Out::take) } 923 | } 924 | 925 | fn deserialize_u32($($mut)* self, visitor: V) -> Result 926 | where 927 | V: serde::de::Visitor<'de>, 928 | { 929 | let mut erased = erase::Visitor::new(visitor); 930 | unsafe { self.erased_deserialize_u32(&mut erased).unsafe_map(Out::take) } 931 | } 932 | 933 | fn deserialize_u64($($mut)* self, visitor: V) -> Result 934 | where 935 | V: serde::de::Visitor<'de>, 936 | { 937 | let mut erased = erase::Visitor::new(visitor); 938 | unsafe { self.erased_deserialize_u64(&mut erased).unsafe_map(Out::take) } 939 | } 940 | 941 | fn deserialize_u128($($mut)* self, visitor: V) -> Result 942 | where 943 | V: serde::de::Visitor<'de>, 944 | { 945 | let mut erased = erase::Visitor::new(visitor); 946 | unsafe { self.erased_deserialize_u128(&mut erased).unsafe_map(Out::take) } 947 | } 948 | 949 | fn deserialize_f32($($mut)* self, visitor: V) -> Result 950 | where 951 | V: serde::de::Visitor<'de>, 952 | { 953 | let mut erased = erase::Visitor::new(visitor); 954 | unsafe { self.erased_deserialize_f32(&mut erased).unsafe_map(Out::take) } 955 | } 956 | 957 | fn deserialize_f64($($mut)* self, visitor: V) -> Result 958 | where 959 | V: serde::de::Visitor<'de>, 960 | { 961 | let mut erased = erase::Visitor::new(visitor); 962 | unsafe { self.erased_deserialize_f64(&mut erased).unsafe_map(Out::take) } 963 | } 964 | 965 | fn deserialize_char($($mut)* self, visitor: V) -> Result 966 | where 967 | V: serde::de::Visitor<'de>, 968 | { 969 | let mut erased = erase::Visitor::new(visitor); 970 | unsafe { self.erased_deserialize_char(&mut erased).unsafe_map(Out::take) } 971 | } 972 | 973 | fn deserialize_str($($mut)* self, visitor: V) -> Result 974 | where 975 | V: serde::de::Visitor<'de>, 976 | { 977 | let mut erased = erase::Visitor::new(visitor); 978 | unsafe { self.erased_deserialize_str(&mut erased).unsafe_map(Out::take) } 979 | } 980 | 981 | fn deserialize_string($($mut)* self, visitor: V) -> Result 982 | where 983 | V: serde::de::Visitor<'de>, 984 | { 985 | let mut erased = erase::Visitor::new(visitor); 986 | unsafe { self.erased_deserialize_string(&mut erased).unsafe_map(Out::take) } 987 | } 988 | 989 | fn deserialize_bytes($($mut)* self, visitor: V) -> Result 990 | where 991 | V: serde::de::Visitor<'de>, 992 | { 993 | let mut erased = erase::Visitor::new(visitor); 994 | unsafe { self.erased_deserialize_bytes(&mut erased).unsafe_map(Out::take) } 995 | } 996 | 997 | fn deserialize_byte_buf($($mut)* self, visitor: V) -> Result 998 | where 999 | V: serde::de::Visitor<'de>, 1000 | { 1001 | let mut erased = erase::Visitor::new(visitor); 1002 | unsafe { self.erased_deserialize_byte_buf(&mut erased).unsafe_map(Out::take) } 1003 | } 1004 | 1005 | fn deserialize_option($($mut)* self, visitor: V) -> Result 1006 | where 1007 | V: serde::de::Visitor<'de>, 1008 | { 1009 | let mut erased = erase::Visitor::new(visitor); 1010 | unsafe { self.erased_deserialize_option(&mut erased).unsafe_map(Out::take) } 1011 | } 1012 | 1013 | fn deserialize_unit($($mut)* self, visitor: V) -> Result 1014 | where 1015 | V: serde::de::Visitor<'de>, 1016 | { 1017 | let mut erased = erase::Visitor::new(visitor); 1018 | unsafe { self.erased_deserialize_unit(&mut erased).unsafe_map(Out::take) } 1019 | } 1020 | 1021 | fn deserialize_unit_struct($($mut)* self, name: &'static str, visitor: V) -> Result 1022 | where 1023 | V: serde::de::Visitor<'de>, 1024 | { 1025 | let mut erased = erase::Visitor::new(visitor); 1026 | unsafe { self.erased_deserialize_unit_struct(name, &mut erased).unsafe_map(Out::take) } 1027 | } 1028 | 1029 | fn deserialize_newtype_struct($($mut)* self, name: &'static str, visitor: V) -> Result 1030 | where 1031 | V: serde::de::Visitor<'de>, 1032 | { 1033 | let mut erased = erase::Visitor::new(visitor); 1034 | unsafe { self.erased_deserialize_newtype_struct(name, &mut erased).unsafe_map(Out::take) } 1035 | } 1036 | 1037 | fn deserialize_seq($($mut)* self, visitor: V) -> Result 1038 | where 1039 | V: serde::de::Visitor<'de>, 1040 | { 1041 | let mut erased = erase::Visitor::new(visitor); 1042 | unsafe { self.erased_deserialize_seq(&mut erased).unsafe_map(Out::take) } 1043 | } 1044 | 1045 | fn deserialize_tuple($($mut)* self, len: usize, visitor: V) -> Result 1046 | where 1047 | V: serde::de::Visitor<'de>, 1048 | { 1049 | let mut erased = erase::Visitor::new(visitor); 1050 | unsafe { self.erased_deserialize_tuple(len, &mut erased).unsafe_map(Out::take) } 1051 | } 1052 | 1053 | fn deserialize_tuple_struct($($mut)* self, name: &'static str, len: usize, visitor: V) -> Result 1054 | where 1055 | V: serde::de::Visitor<'de>, 1056 | { 1057 | let mut erased = erase::Visitor::new(visitor); 1058 | unsafe { self.erased_deserialize_tuple_struct(name, len, &mut erased).unsafe_map(Out::take) } 1059 | } 1060 | 1061 | fn deserialize_map($($mut)* self, visitor: V) -> Result 1062 | where 1063 | V: serde::de::Visitor<'de>, 1064 | { 1065 | let mut erased = erase::Visitor::new(visitor); 1066 | unsafe { self.erased_deserialize_map(&mut erased).unsafe_map(Out::take) } 1067 | } 1068 | 1069 | fn deserialize_struct($($mut)* self, name: &'static str, fields: &'static [&'static str], visitor: V) -> Result 1070 | where 1071 | V: serde::de::Visitor<'de>, 1072 | { 1073 | let mut erased = erase::Visitor::new(visitor); 1074 | unsafe { self.erased_deserialize_struct(name, fields, &mut erased).unsafe_map(Out::take) } 1075 | } 1076 | 1077 | fn deserialize_identifier($($mut)* self, visitor: V) -> Result 1078 | where 1079 | V: serde::de::Visitor<'de>, 1080 | { 1081 | let mut erased = erase::Visitor::new(visitor); 1082 | unsafe { self.erased_deserialize_identifier(&mut erased).unsafe_map(Out::take) } 1083 | } 1084 | 1085 | fn deserialize_enum($($mut)* self, name: &'static str, variants: &'static [&'static str], visitor: V) -> Result 1086 | where 1087 | V: serde::de::Visitor<'de>, 1088 | { 1089 | let mut erased = erase::Visitor::new(visitor); 1090 | unsafe { self.erased_deserialize_enum(name, variants, &mut erased).unsafe_map(Out::take) } 1091 | } 1092 | 1093 | fn deserialize_ignored_any($($mut)* self, visitor: V) -> Result 1094 | where 1095 | V: serde::de::Visitor<'de>, 1096 | { 1097 | let mut erased = erase::Visitor::new(visitor); 1098 | unsafe { self.erased_deserialize_ignored_any(&mut erased).unsafe_map(Out::take) } 1099 | } 1100 | 1101 | fn is_human_readable(&self) -> bool { 1102 | self.erased_is_human_readable() 1103 | } 1104 | } 1105 | }; 1106 | } 1107 | 1108 | impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + '_)); 1109 | impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + Send + '_)); 1110 | impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + Sync + '_)); 1111 | impl_deserializer_for_trait_object!({} &mut (dyn Deserializer<'de> + Send + Sync + '_)); 1112 | impl_deserializer_for_trait_object!({mut} Box + '_>); 1113 | impl_deserializer_for_trait_object!({mut} Box + Send + '_>); 1114 | impl_deserializer_for_trait_object!({mut} Box + Sync + '_>); 1115 | impl_deserializer_for_trait_object!({mut} Box + Send + Sync + '_>); 1116 | 1117 | impl<'de> serde::de::Visitor<'de> for &mut (dyn Visitor<'de> + '_) { 1118 | type Value = Out; 1119 | 1120 | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 1121 | (**self).erased_expecting(formatter) 1122 | } 1123 | 1124 | fn visit_bool(self, v: bool) -> Result 1125 | where 1126 | E: serde::de::Error, 1127 | { 1128 | self.erased_visit_bool(v).map_err(unerase) 1129 | } 1130 | 1131 | fn visit_i8(self, v: i8) -> Result 1132 | where 1133 | E: serde::de::Error, 1134 | { 1135 | self.erased_visit_i8(v).map_err(unerase) 1136 | } 1137 | 1138 | fn visit_i16(self, v: i16) -> Result 1139 | where 1140 | E: serde::de::Error, 1141 | { 1142 | self.erased_visit_i16(v).map_err(unerase) 1143 | } 1144 | 1145 | fn visit_i32(self, v: i32) -> Result 1146 | where 1147 | E: serde::de::Error, 1148 | { 1149 | self.erased_visit_i32(v).map_err(unerase) 1150 | } 1151 | 1152 | fn visit_i64(self, v: i64) -> Result 1153 | where 1154 | E: serde::de::Error, 1155 | { 1156 | self.erased_visit_i64(v).map_err(unerase) 1157 | } 1158 | 1159 | fn visit_i128(self, v: i128) -> Result 1160 | where 1161 | E: serde::de::Error, 1162 | { 1163 | self.erased_visit_i128(v).map_err(unerase) 1164 | } 1165 | 1166 | fn visit_u8(self, v: u8) -> Result 1167 | where 1168 | E: serde::de::Error, 1169 | { 1170 | self.erased_visit_u8(v).map_err(unerase) 1171 | } 1172 | 1173 | fn visit_u16(self, v: u16) -> Result 1174 | where 1175 | E: serde::de::Error, 1176 | { 1177 | self.erased_visit_u16(v).map_err(unerase) 1178 | } 1179 | 1180 | fn visit_u32(self, v: u32) -> Result 1181 | where 1182 | E: serde::de::Error, 1183 | { 1184 | self.erased_visit_u32(v).map_err(unerase) 1185 | } 1186 | 1187 | fn visit_u64(self, v: u64) -> Result 1188 | where 1189 | E: serde::de::Error, 1190 | { 1191 | self.erased_visit_u64(v).map_err(unerase) 1192 | } 1193 | 1194 | fn visit_u128(self, v: u128) -> Result 1195 | where 1196 | E: serde::de::Error, 1197 | { 1198 | self.erased_visit_u128(v).map_err(unerase) 1199 | } 1200 | 1201 | fn visit_f32(self, v: f32) -> Result 1202 | where 1203 | E: serde::de::Error, 1204 | { 1205 | self.erased_visit_f32(v).map_err(unerase) 1206 | } 1207 | 1208 | fn visit_f64(self, v: f64) -> Result 1209 | where 1210 | E: serde::de::Error, 1211 | { 1212 | self.erased_visit_f64(v).map_err(unerase) 1213 | } 1214 | 1215 | fn visit_char(self, v: char) -> Result 1216 | where 1217 | E: serde::de::Error, 1218 | { 1219 | self.erased_visit_char(v).map_err(unerase) 1220 | } 1221 | 1222 | fn visit_str(self, v: &str) -> Result 1223 | where 1224 | E: serde::de::Error, 1225 | { 1226 | self.erased_visit_str(v).map_err(unerase) 1227 | } 1228 | 1229 | fn visit_borrowed_str(self, v: &'de str) -> Result 1230 | where 1231 | E: serde::de::Error, 1232 | { 1233 | self.erased_visit_borrowed_str(v).map_err(unerase) 1234 | } 1235 | 1236 | #[cfg(feature = "alloc")] 1237 | fn visit_string(self, v: String) -> Result 1238 | where 1239 | E: serde::de::Error, 1240 | { 1241 | self.erased_visit_string(v).map_err(unerase) 1242 | } 1243 | 1244 | fn visit_bytes(self, v: &[u8]) -> Result 1245 | where 1246 | E: serde::de::Error, 1247 | { 1248 | self.erased_visit_bytes(v).map_err(unerase) 1249 | } 1250 | 1251 | fn visit_borrowed_bytes(self, v: &'de [u8]) -> Result 1252 | where 1253 | E: serde::de::Error, 1254 | { 1255 | self.erased_visit_borrowed_bytes(v).map_err(unerase) 1256 | } 1257 | 1258 | #[cfg(feature = "alloc")] 1259 | fn visit_byte_buf(self, v: Vec) -> Result 1260 | where 1261 | E: serde::de::Error, 1262 | { 1263 | self.erased_visit_byte_buf(v).map_err(unerase) 1264 | } 1265 | 1266 | fn visit_none(self) -> Result 1267 | where 1268 | E: serde::de::Error, 1269 | { 1270 | self.erased_visit_none().map_err(unerase) 1271 | } 1272 | 1273 | fn visit_some(self, deserializer: D) -> Result 1274 | where 1275 | D: serde::Deserializer<'de>, 1276 | { 1277 | let mut erased = erase::Deserializer::new(deserializer); 1278 | self.erased_visit_some(&mut erased).map_err(unerase) 1279 | } 1280 | 1281 | fn visit_unit(self) -> Result 1282 | where 1283 | E: serde::de::Error, 1284 | { 1285 | self.erased_visit_unit().map_err(unerase) 1286 | } 1287 | 1288 | fn visit_newtype_struct(self, deserializer: D) -> Result 1289 | where 1290 | D: serde::Deserializer<'de>, 1291 | { 1292 | let mut erased = erase::Deserializer::new(deserializer); 1293 | self.erased_visit_newtype_struct(&mut erased) 1294 | .map_err(unerase) 1295 | } 1296 | 1297 | fn visit_seq(self, seq: V) -> Result 1298 | where 1299 | V: serde::de::SeqAccess<'de>, 1300 | { 1301 | let mut erased = erase::SeqAccess::new(seq); 1302 | self.erased_visit_seq(&mut erased).map_err(unerase) 1303 | } 1304 | 1305 | fn visit_map(self, map: V) -> Result 1306 | where 1307 | V: serde::de::MapAccess<'de>, 1308 | { 1309 | let mut erased = erase::MapAccess::new(map); 1310 | self.erased_visit_map(&mut erased).map_err(unerase) 1311 | } 1312 | 1313 | fn visit_enum(self, data: V) -> Result 1314 | where 1315 | V: serde::de::EnumAccess<'de>, 1316 | { 1317 | let mut erased = erase::EnumAccess::new(data); 1318 | self.erased_visit_enum(&mut erased).map_err(unerase) 1319 | } 1320 | } 1321 | 1322 | impl<'de> serde::de::SeqAccess<'de> for &mut (dyn SeqAccess<'de> + '_) { 1323 | type Error = Error; 1324 | 1325 | fn next_element_seed(&mut self, seed: T) -> Result, Error> 1326 | where 1327 | T: serde::de::DeserializeSeed<'de>, 1328 | { 1329 | let mut seed = erase::DeserializeSeed::new(seed); 1330 | unsafe { 1331 | (**self) 1332 | .erased_next_element(&mut seed) 1333 | .map(|opt| opt.unsafe_map(Out::take)) 1334 | } 1335 | } 1336 | 1337 | fn size_hint(&self) -> Option { 1338 | (**self).erased_size_hint() 1339 | } 1340 | } 1341 | 1342 | impl<'de> serde::de::MapAccess<'de> for &mut (dyn MapAccess<'de> + '_) { 1343 | type Error = Error; 1344 | 1345 | fn next_key_seed(&mut self, seed: K) -> Result, Error> 1346 | where 1347 | K: serde::de::DeserializeSeed<'de>, 1348 | { 1349 | let mut erased = erase::DeserializeSeed::new(seed); 1350 | unsafe { 1351 | (**self) 1352 | .erased_next_key(&mut erased) 1353 | .map(|opt| opt.unsafe_map(Out::take)) 1354 | } 1355 | } 1356 | 1357 | fn next_value_seed(&mut self, seed: V) -> Result 1358 | where 1359 | V: serde::de::DeserializeSeed<'de>, 1360 | { 1361 | let mut erased = erase::DeserializeSeed::new(seed); 1362 | unsafe { 1363 | (**self) 1364 | .erased_next_value(&mut erased) 1365 | .unsafe_map(Out::take) 1366 | } 1367 | } 1368 | 1369 | fn size_hint(&self) -> Option { 1370 | (**self).erased_size_hint() 1371 | } 1372 | } 1373 | 1374 | impl<'de> serde::de::EnumAccess<'de> for &mut (dyn EnumAccess<'de> + '_) { 1375 | type Error = Error; 1376 | type Variant = Variant<'de>; 1377 | 1378 | fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> 1379 | where 1380 | V: serde::de::DeserializeSeed<'de>, 1381 | { 1382 | let mut erased = erase::DeserializeSeed::new(seed); 1383 | match self.erased_variant_seed(&mut erased) { 1384 | Ok((out, variant)) => Ok((unsafe { out.take() }, variant)), 1385 | Err(err) => Err(err), 1386 | } 1387 | } 1388 | } 1389 | 1390 | pub struct Variant<'de> { 1391 | data: Any, 1392 | unit_variant: unsafe fn(Any) -> Result<(), Error>, 1393 | visit_newtype: unsafe fn(Any, seed: &mut dyn DeserializeSeed<'de>) -> Result, 1394 | tuple_variant: unsafe fn(Any, len: usize, visitor: &mut dyn Visitor<'de>) -> Result, 1395 | struct_variant: unsafe fn( 1396 | Any, 1397 | fields: &'static [&'static str], 1398 | visitor: &mut dyn Visitor<'de>, 1399 | ) -> Result, 1400 | } 1401 | 1402 | impl<'de> serde::de::VariantAccess<'de> for Variant<'de> { 1403 | type Error = Error; 1404 | 1405 | fn unit_variant(self) -> Result<(), Error> { 1406 | unsafe { (self.unit_variant)(self.data) } 1407 | } 1408 | 1409 | fn newtype_variant_seed(self, seed: T) -> Result 1410 | where 1411 | T: serde::de::DeserializeSeed<'de>, 1412 | { 1413 | let mut erased = erase::DeserializeSeed::new(seed); 1414 | unsafe { (self.visit_newtype)(self.data, &mut erased).unsafe_map(Out::take) } 1415 | } 1416 | 1417 | fn tuple_variant(self, len: usize, visitor: V) -> Result 1418 | where 1419 | V: serde::de::Visitor<'de>, 1420 | { 1421 | let mut erased = erase::Visitor::new(visitor); 1422 | unsafe { (self.tuple_variant)(self.data, len, &mut erased).unsafe_map(Out::take) } 1423 | } 1424 | 1425 | fn struct_variant( 1426 | self, 1427 | fields: &'static [&'static str], 1428 | visitor: V, 1429 | ) -> Result 1430 | where 1431 | V: serde::de::Visitor<'de>, 1432 | { 1433 | let mut erased = erase::Visitor::new(visitor); 1434 | unsafe { (self.struct_variant)(self.data, fields, &mut erased).unsafe_map(Out::take) } 1435 | } 1436 | } 1437 | 1438 | // IMPL ERASED SERDE FOR ERASED SERDE ////////////////////////////////////////// 1439 | 1440 | macro_rules! deref_erased_deserializer { 1441 | (<'de $(, $T:ident)*> Deserializer<'de> for $ty:ty $(where $($where:tt)*)?) => { 1442 | impl<'de $(, $T)*> Deserializer<'de> for $ty $(where $($where)*)? { 1443 | fn erased_deserialize_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1444 | (**self).erased_deserialize_any(visitor) 1445 | } 1446 | 1447 | fn erased_deserialize_bool(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1448 | (**self).erased_deserialize_bool(visitor) 1449 | } 1450 | 1451 | fn erased_deserialize_i8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1452 | (**self).erased_deserialize_i8(visitor) 1453 | } 1454 | 1455 | fn erased_deserialize_i16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1456 | (**self).erased_deserialize_i16(visitor) 1457 | } 1458 | 1459 | fn erased_deserialize_i32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1460 | (**self).erased_deserialize_i32(visitor) 1461 | } 1462 | 1463 | fn erased_deserialize_i64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1464 | (**self).erased_deserialize_i64(visitor) 1465 | } 1466 | 1467 | fn erased_deserialize_i128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1468 | (**self).erased_deserialize_i128(visitor) 1469 | } 1470 | 1471 | fn erased_deserialize_u8(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1472 | (**self).erased_deserialize_u8(visitor) 1473 | } 1474 | 1475 | fn erased_deserialize_u16(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1476 | (**self).erased_deserialize_u16(visitor) 1477 | } 1478 | 1479 | fn erased_deserialize_u32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1480 | (**self).erased_deserialize_u32(visitor) 1481 | } 1482 | 1483 | fn erased_deserialize_u64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1484 | (**self).erased_deserialize_u64(visitor) 1485 | } 1486 | 1487 | fn erased_deserialize_u128(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1488 | (**self).erased_deserialize_u128(visitor) 1489 | } 1490 | 1491 | fn erased_deserialize_f32(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1492 | (**self).erased_deserialize_f32(visitor) 1493 | } 1494 | 1495 | fn erased_deserialize_f64(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1496 | (**self).erased_deserialize_f64(visitor) 1497 | } 1498 | 1499 | fn erased_deserialize_char(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1500 | (**self).erased_deserialize_char(visitor) 1501 | } 1502 | 1503 | fn erased_deserialize_str(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1504 | (**self).erased_deserialize_str(visitor) 1505 | } 1506 | 1507 | fn erased_deserialize_string(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1508 | (**self).erased_deserialize_string(visitor) 1509 | } 1510 | 1511 | fn erased_deserialize_bytes(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1512 | (**self).erased_deserialize_bytes(visitor) 1513 | } 1514 | 1515 | fn erased_deserialize_byte_buf(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1516 | (**self).erased_deserialize_byte_buf(visitor) 1517 | } 1518 | 1519 | fn erased_deserialize_option(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1520 | (**self).erased_deserialize_option(visitor) 1521 | } 1522 | 1523 | fn erased_deserialize_unit(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1524 | (**self).erased_deserialize_unit(visitor) 1525 | } 1526 | 1527 | fn erased_deserialize_unit_struct(&mut self, name: &'static str, visitor: &mut dyn Visitor<'de>) -> Result { 1528 | (**self).erased_deserialize_unit_struct(name, visitor) 1529 | } 1530 | 1531 | fn erased_deserialize_newtype_struct(&mut self, name: &'static str, visitor: &mut dyn Visitor<'de>) -> Result { 1532 | (**self).erased_deserialize_newtype_struct(name, visitor) 1533 | } 1534 | 1535 | fn erased_deserialize_seq(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1536 | (**self).erased_deserialize_seq(visitor) 1537 | } 1538 | 1539 | fn erased_deserialize_tuple(&mut self, len: usize, visitor: &mut dyn Visitor<'de>) -> Result { 1540 | (**self).erased_deserialize_tuple(len, visitor) 1541 | } 1542 | 1543 | fn erased_deserialize_tuple_struct(&mut self, name: &'static str, len: usize, visitor: &mut dyn Visitor<'de>) -> Result { 1544 | (**self).erased_deserialize_tuple_struct(name, len, visitor) 1545 | } 1546 | 1547 | fn erased_deserialize_map(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1548 | (**self).erased_deserialize_map(visitor) 1549 | } 1550 | 1551 | fn erased_deserialize_struct(&mut self, name: &'static str, fields: &'static [&'static str], visitor: &mut dyn Visitor<'de>) -> Result { 1552 | (**self).erased_deserialize_struct(name, fields, visitor) 1553 | } 1554 | 1555 | fn erased_deserialize_identifier(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1556 | (**self).erased_deserialize_identifier(visitor) 1557 | } 1558 | 1559 | fn erased_deserialize_enum(&mut self, name: &'static str, variants: &'static [&'static str], visitor: &mut dyn Visitor<'de>) -> Result { 1560 | (**self).erased_deserialize_enum(name, variants, visitor) 1561 | } 1562 | 1563 | fn erased_deserialize_ignored_any(&mut self, visitor: &mut dyn Visitor<'de>) -> Result { 1564 | (**self).erased_deserialize_ignored_any(visitor) 1565 | } 1566 | 1567 | fn erased_is_human_readable(&self) -> bool { 1568 | (**self).erased_is_human_readable() 1569 | } 1570 | } 1571 | 1572 | impl<'de $(, $T)*> Sealed for $ty $(where $($where)*)? {} 1573 | }; 1574 | } 1575 | 1576 | deref_erased_deserializer!(<'de, T> Deserializer<'de> for &mut T where T: ?Sized + Deserializer<'de>); 1577 | deref_erased_deserializer!(<'de, T> Deserializer<'de> for Box where T: ?Sized + Deserializer<'de>); 1578 | 1579 | // TEST //////////////////////////////////////////////////////////////////////// 1580 | 1581 | #[cfg(test)] 1582 | mod tests { 1583 | use super::*; 1584 | use alloc::borrow::ToOwned; 1585 | use core::fmt::Debug; 1586 | use serde_derive::Deserialize; 1587 | 1588 | fn test_json<'de, T>(json: &'de [u8]) 1589 | where 1590 | T: serde::Deserialize<'de> + PartialEq + Debug, 1591 | { 1592 | let expected: T = serde_json::from_slice(json).unwrap(); 1593 | 1594 | // test borrowed trait object 1595 | { 1596 | let mut de = serde_json::Deserializer::from_slice(json); 1597 | let de: &mut dyn Deserializer = &mut ::erase(&mut de); 1598 | assert_eq!(expected, deserialize::(de).unwrap()); 1599 | } 1600 | 1601 | // test boxed trait object 1602 | { 1603 | let mut de = serde_json::Deserializer::from_slice(json); 1604 | let mut de: Box = Box::new(::erase(&mut de)); 1605 | assert_eq!(expected, deserialize::(&mut de).unwrap()); 1606 | } 1607 | } 1608 | 1609 | #[test] 1610 | fn test_value() { 1611 | test_json::(br#"["a", 1, [true], {"a": 1}]"#); 1612 | } 1613 | 1614 | #[test] 1615 | fn test_struct() { 1616 | #[derive(Deserialize, PartialEq, Debug)] 1617 | struct S { 1618 | f: usize, 1619 | } 1620 | 1621 | test_json::(br#"{"f":256}"#); 1622 | } 1623 | 1624 | #[test] 1625 | fn test_enum() { 1626 | #[derive(Deserialize, PartialEq, Debug)] 1627 | enum E { 1628 | Unit, 1629 | Newtype(bool), 1630 | Tuple(bool, bool), 1631 | Struct { t: bool, f: bool }, 1632 | } 1633 | 1634 | test_json::(br#""Unit""#); 1635 | test_json::(br#"{"Newtype":true}"#); 1636 | test_json::(br#"{"Tuple":[true,false]}"#); 1637 | test_json::(br#"{"Struct":{"t":true,"f":false}}"#); 1638 | } 1639 | 1640 | #[test] 1641 | fn test_borrowed() { 1642 | let bytes = br#""borrowed""#.to_owned(); 1643 | test_json::<&str>(&bytes); 1644 | } 1645 | 1646 | #[test] 1647 | fn assert_deserializer() { 1648 | fn assert<'de, T: serde::Deserializer<'de>>() {} 1649 | 1650 | assert::<&mut dyn Deserializer>(); 1651 | assert::<&mut (dyn Deserializer + Send)>(); 1652 | assert::<&mut (dyn Deserializer + Sync)>(); 1653 | assert::<&mut (dyn Deserializer + Send + Sync)>(); 1654 | assert::<&mut (dyn Deserializer + Sync + Send)>(); 1655 | 1656 | assert::>(); 1657 | assert::>(); 1658 | assert::>(); 1659 | assert::>(); 1660 | assert::>(); 1661 | } 1662 | 1663 | #[test] 1664 | fn test_dangle() { 1665 | let mut json_deserializer = serde_json::Deserializer::from_str(""); 1666 | let _erased_deserializer = ::erase(&mut json_deserializer); 1667 | drop(json_deserializer); 1668 | } 1669 | } 1670 | --------------------------------------------------------------------------------