How to transform fields during serialization using Serde?

by

The serialize_with attribute

You can use the serialize_with attribute to provide a custom serialization function for your field:

use serde::{Serialize, Serializer}; // 1.0.104

fn round_serialize<S>(x: &f32, s: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    s.serialize_f32(x.round())
}

#[derive(Debug, Serialize)]
pub struct NodeLocation {
    #[serde(rename = "nodeId")]
    id: u32,
    #[serde(serialize_with = "round_serialize")]
    lat: f32,
    #[serde(serialize_with = "round_serialize")]
    lon: f32,
}

(I’ve rounded to the nearest integer to avoid the topic “what is best way to round a float to k decimal places”).

Implement serde::Serialize

The other semi-manual approach is to create a separate struct with auto-derived serialization, and implement your serialization using that:

use serde::{Serialize, Serializer}; // 1.0.104

#[derive(Debug)]
pub struct NodeLocation {
    id: u32,
    lat: f32,
    lon: f32,
}

impl serde::Serialize for NodeLocation {
    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Implement your preprocessing in `from`.
        RoundedNodeLocation::from(self).serialize(s)
    }
}

#[derive(Debug, Serialize)]
pub struct RoundedNodeLocation {
    #[serde(rename = "nodeId")]
    id: u32,
    lat: f32,
    lon: f32,
}

impl<'a> From<&'a NodeLocation> for RoundedNodeLocation {
    fn from(other: &'a NodeLocation) -> Self {
        Self {
            id: other.id,
            lat: other.lat.round(),
            lon: other.lon.round(),
        }
    }
}

Notably, this allows you to also add or remove fields as the “inner” serialized type can do basically whatever it wants.

More Related Contents:

  1. Why is a trait not implemented for a type that clearly has it implemented?
  2. How to transform fields during deserialization using Serde?
  3. Lifetime error when creating a function that returns a value implementing serde::Deserialize
  4. How can I distinguish between a deserialized field that is missing and one that is null?
  5. How to implement `serde::Serialize` for a boxed trait object?
  6. How to fix lifetime error when function returns a serde Deserialize type?
  7. Why can Serde not derive Deserialize for a struct containing only a &Path?
  8. Return local String as a slice (&str)
  9. What is the difference between iter and into_iter?
  10. How can I swap in a new value for a field in a mutable reference to a structure?
  11. How to convert a String into a &’static str
  12. Proper way to return a new string in Rust
  13. Double mutable borrow error in a loop happens even with NLL on
  14. println! error: expected a literal / format argument must be a string literal
  15. How to return a reference to a sub-value of a value that is under a mutex?
  16. “borrowed value does not live long enough” when using the builder pattern
  17. Is it possible to conditionally enable an attribute like `derive`?
  18. cannot borrow `self.x` as immutable because `*self` is also borrowed as mutable
  19. Using the same iterator multiple times in Rust
  20. How do I fix “cannot find derive macro in this scope”?
  21. Thread ” has overflowed its stack when allocating a large array using Box
  22. How do you enable a Rust “crate feature”?
  23. How to implement Iterator yielding mutable references [duplicate]
  24. How can a Rust program access metadata from its Cargo package?
  25. How can the ref keyword be avoided when pattern matching in a function taking &self or &mut self?
  26. How to swap two variables?
  27. Expected bound lifetime parameter, found concrete lifetime [E0271]
  28. How do I change a function’s qualifiers via conditional compilation?
  29. Comparing every element in a vector with the next one
  30. How to concatenate static strings in Rust

Leave a Comment