serdev 0.3.2

SerdeV - Serde with Validation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#![feature(test)]

extern crate test;

use std::sync::LazyLock;
use test::bench::Bencher;

#[allow(unused)]
struct S {
    a: String,
    b: usize,
    c: Vec<T>,
}

#[derive(Clone)]
struct SP {
    a: String,
    b: usize,
    c: Vec<T>,
}

#[allow(unused)]
#[derive(Clone)]
struct T {
    d: usize,
    e: String,
}

static CASES: LazyLock<[SP; 100]> = LazyLock::new(|| {
    use rand::{Rng, rng};

    fn random_string() -> String {
        use rand::distr::{Alphanumeric, SampleString};
        let len = rng().random_range(0..100);
        Alphanumeric.sample_string(&mut rng(), len)
    }

    fn random_uint() -> usize {
        rng().random::<u64>() as usize
    }

    (0..100)
        .map(|_| SP {
            a: random_string(),
            b: random_uint(),
            c: (0..100)
                .map(|_| T {
                    d: random_uint(),
                    e: random_string(),
                })
                .collect(),
        })
        .collect::<Vec<_>>()
        .try_into()
        .ok()
        .unwrap()
});

#[bench]
fn transfer_by_hand(b: &mut Bencher) {
    test::black_box(&*CASES);
    b.iter(|| -> [S; 100] {
        CASES.clone().map(|sp| {
            test::black_box(S {
                a: sp.a,
                b: sp.b,
                c: sp.c,
            })
        })
    })
}

#[bench]
fn transfer_by_mem_transmute(b: &mut Bencher) {
    test::black_box(&*CASES);
    b.iter(|| -> [S; 100] {
        CASES
            .clone()
            .map(|sp| test::black_box(unsafe { std::mem::transmute::<SP, S>(sp) }))
    })
}