6 releases

0.2.1 May 19, 2022
0.2.0 Sep 15, 2021
0.1.2 May 26, 2021
0.1.1 Sep 1, 2020
0.0.0 May 12, 2020

#1444 in Encoding

Download history 16600/week @ 2025-03-12 16272/week @ 2025-03-19 17716/week @ 2025-03-26 16752/week @ 2025-04-02 19157/week @ 2025-04-09 17864/week @ 2025-04-16 20702/week @ 2025-04-23 14856/week @ 2025-04-30 17469/week @ 2025-05-07 16776/week @ 2025-05-14 13614/week @ 2025-05-21 16376/week @ 2025-05-28 17876/week @ 2025-06-04 16905/week @ 2025-06-11 18197/week @ 2025-06-18 20587/week @ 2025-06-25

76,805 downloads per month
Used in 134 crates (7 directly)

MIT/Apache

20KB
388 lines

serde-name

serde-name on crates.io Documentation (latest release) License License

This crate provides fast and reliable ways to extract and to override the Serde name of a Rust container.

Extracting Serde names

Name extraction relies on the Deserialize trait of Serde:

#[derive(Deserialize)]
struct Foo {
  bar: Bar,
}

#[derive(Deserialize)]
#[serde(rename = "ABC")]
enum Bar { A, B, C }

assert_eq!(trace_name::<Foo>(), Some("Foo"));
assert_eq!(trace_name::<Bar>(), Some("ABC"));
assert_eq!(trace_name::<Option<Bar>>(), None);

Overriding Serde names

SerializeNameAdapter and DeserializeNameAdapter may be used to override the name of a container in the cases where #[serde(rename = "..")] is not flexible enough.

#[derive(Serialize, Deserialize)]
#[serde(remote = "Foo")] // Generates Foo::(de)serialize instead of implementing Serde traits.
struct Foo<T> {
    data: T,
}

impl<'de, T> Deserialize<'de> for Foo<T>
where
    T: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::de::Deserializer<'de>,
    {
        Foo::deserialize(DeserializeNameAdapter::new(
            deserializer,
            std::any::type_name::<Self>(),
        ))
    }
}

impl<T> Serialize for Foo<T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::ser::Serializer,
    {
        Foo::serialize(
            self,
            SerializeNameAdapter::new(serializer, std::any::type_name::<Self>()),
        )
    }
}

// Testing the Deserialize implementation
assert!(trace_name::<Foo<u64>>().unwrap().ends_with("Foo<u64>"));

// Testing the Serialize implementation
use serde_reflection::*;
let mut tracer = Tracer::new(TracerConfig::default());
let mut samples = Samples::new();
let (mut ident, _) = tracer.trace_value(&mut samples, &Foo { data: 1u64 }).unwrap();
ident.normalize().unwrap();
assert!(matches!(ident, Format::TypeName(s) if s.ends_with("Foo<u64>")));

Contributing

See the CONTRIBUTING file for how to help out.

License

This project is available under the terms of either the Apache 2.0 license or the MIT license.

Dependencies

~0.3–0.9MB
~20K SLoC