#stack-overflow #serde #serialization #nested #data #recursion #adapter

serde_stacker

Serde adapter that avoids stack overflow by dynamically growing the stack

12 releases

0.1.11 Jan 2, 2024
0.1.10 Jul 15, 2023
0.1.8 Mar 3, 2023
0.1.7 Dec 17, 2022
0.1.0 Jan 13, 2019

#1045 in Encoding

Download history 7607/week @ 2024-06-13 9290/week @ 2024-06-20 8414/week @ 2024-06-27 8385/week @ 2024-07-04 9011/week @ 2024-07-11 9539/week @ 2024-07-18 12555/week @ 2024-07-25 36740/week @ 2024-08-01 11950/week @ 2024-08-08 11067/week @ 2024-08-15 9054/week @ 2024-08-22 8805/week @ 2024-08-29 8415/week @ 2024-09-05 8923/week @ 2024-09-12 10009/week @ 2024-09-19 8339/week @ 2024-09-26

37,938 downloads per month
Used in 28 crates (17 directly)

MIT/Apache

43KB
1K SLoC

Serde stack growth adapter

github crates.io docs.rs build status

This crate provides a Serde adapter that avoids stack overflow by dynamically growing the stack.

Be aware that you may need to protect against other recursive operations outside of serialization and deserialization when working with deeply nested data, including, but not limited to, Display and Debug and Drop impls.

[dependencies]
serde = "1.0"
serde_stacker = "0.1"

Deserialization example

use serde::Deserialize;
use serde_json::Value;

fn main() {
    let mut json = String::new();
    for _ in 0..10000 {
        json = format!("[{}]", json);
    }

    let mut deserializer = serde_json::Deserializer::from_str(&json);
    deserializer.disable_recursion_limit();
    let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
    let value = Value::deserialize(deserializer).unwrap();

    carefully_drop_nested_arrays(value);
}

fn carefully_drop_nested_arrays(value: Value) {
    let mut stack = vec![value];
    while let Some(value) = stack.pop() {
        if let Value::Array(array) = value {
            stack.extend(array);
        }
    }
}

Serialization example

use serde::Serialize;
use serde_json::Value;

fn main() {
    let mut value = Value::Null;
    for _ in 0..10000 {
        value = Value::Array(vec![value]);
    }

    let mut out = Vec::new();
    let mut serializer = serde_json::Serializer::new(&mut out);
    let serializer = serde_stacker::Serializer::new(&mut serializer);
    let result = value.serialize(serializer);

    carefully_drop_nested_arrays(value);

    result.unwrap();
    assert_eq!(out.len(), 10000 + "null".len() + 10000);
}

fn carefully_drop_nested_arrays(value: Value) {
    let mut stack = vec![value];
    while let Some(value) = stack.pop() {
        if let Value::Array(array) = value {
            stack.extend(array);
        }
    }
}

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Dependencies

~0.2–7MB
~50K SLoC