Rust - Implementing custom de/serialization logic for specialized vector or map types

Serialization and deserialization are critical processes in software development that allow for data representation and storage in different formats. In Rust, the serde library is widely used for this purpose. While serde provides excellent default serialization and deserialization logic, sometimes our application demands specialized handling, especially when working with custom vector or map types.

Understanding Custom Serialization and Deserialization

Serialization converts data structures into a format that can be stored or transmitted, while deserialization reconstructs the data structures from that format. Let's see how we can implement custom de/serialization logic for specialized vector or map types in Rust.

Basics of Serde Serialization

First, ensure you have serde added to your Cargo.toml file:

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

The two main traits that we need to implement for custom serialization are Serialize and Deserialize.

Implementing Custom Serialization for a Specialized Vector

Let's consider a scenario with a specialized vector type where we only want to align specific types for unique requirements. Our vector will contain a wrapper struct around integers.

use serde::{Serialize, Serializer, Deserialize, Deserializer};

#[derive(Debug)]
struct MyInt(i32);

#[derive(Debug)]
struct MyVector(Vec);

impl Serialize for MyInt {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        serializer.serialize_i32(self.0)
    }
}

impl<'de> Deserialize<'de> for MyInt {
    fn deserialize(deserializer: D) -> Result
    where
        D: Deserializer<'de>,
    {
        let value = i32::deserialize(deserializer)?;
        Ok(MyInt(value))
    }
}

// Custom serialization logic for MyVector
impl Serialize for MyVector {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        let mut seq = serializer.serialize_seq(Some(self.0.len()))?;
        for my_int in &self.0 {
            seq.serialize_element(my_int)?;
        }
        seq.end()
    }
}

impl<'de> Deserialize<'de> for MyVector {
    fn deserialize(deserializer: D) -> Result
    where
        D: Deserializer<'de>,
    {
        let vec = Vec::::deserialize(deserializer)?;
        Ok(MyVector(vec))
    }
}

Implementing Custom Serialization for a Specialized Map Type

Similar logic can be followed for specialized map types. Let's demonstrate with a simple wrapper around the map structure that uses strings for keys and integers for values.

use serde::ser::{SerializeMap};
use std::collections::HashMap;

#[derive(Debug)]
struct MyMap(HashMap);

// Serialization
impl Serialize for MyMap {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.0.len()))?;
        for (k, v) in &self.0 {
            map.serialize_entry(k, v)?;
        }
        map.end()
    }
}

// Deserialization
impl<'de> Deserialize<'de> for MyMap {
    fn deserialize(deserializer: D) -> Result
    where
        D: Deserializer<'de>,
    {
        let map = HashMap::::deserialize(deserializer)?;
        Ok(MyMap(map))
    }
}

Conclusion

By adopting custom serialization and deserialization logic in your programs, you can handle specialized use cases and ensure that data structures are stored and retrieved as needed. This flexibility makes Rust programs robust and optimized, leading to better performance and more concise code management.