alkahest 0.3.0

Fantastic serialization library with zero-overhead serialization and zero-copy deserialization
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use std::{io::Cursor, marker::PhantomData, mem::size_of};

use crate::{
    buffer::Buffer,
    bytes::Bytes,
    deserialize::{Deserialize, DeserializeError, Deserializer},
    formula::{reference_size, Formula},
    serialize::{write_reference, Serialize, Sizes},
    size::{FixedUsize, FixedUsizeType},
};

/// A formula that can be used to serialize and deserialize data
/// using [`bincode`] crate.
///
/// Any type serializable with `serde` can be used with this formula.
/// If type is not serializable with `bincode` crate it will cause a panic.
/// Deserializing non-compatible type will cause deserialization error.
pub struct Bincode;

impl Formula for Bincode {
    const MAX_STACK_SIZE: Option<usize> = Some(reference_size::<Bytes>());
    const EXACT_SIZE: bool = true;
    const HEAPLESS: bool = false;
}

impl<T> Serialize<Bincode> for T
where
    T: serde::Serialize,
{
    #[inline]
    fn serialize<B>(self, sizes: &mut Sizes, mut buffer: B) -> Result<(), B::Error>
    where
        B: Buffer,
    {
        let options = bincode::config::DefaultOptions::new();

        let size = match bincode::Options::serialized_size(options, &self) {
            Ok(size) => size,
            Err(err) => panic!("Bincode serialization error: {}", err),
        };

        let Ok(size) = FixedUsizeType::try_from(size) else {
            panic!("Bincode serialization uses more that `FixedUsize::MAX` bytes");
        };

        let Ok(size) = FixedUsize::try_from(size) else {
            panic!("Bincode serialization uses more that `usize::MAX` bytes");
        };
        let size: usize = size.into();

        match buffer.reserve_heap(sizes.heap, sizes.stack, size) {
            Err(err) => return Err(err),
            Ok([]) => {} // Nothing to do.
            Ok(bytes) => {
                let mut cursor = Cursor::new(&mut bytes[sizes.heap..]);
                if let Err(err) = bincode::Options::serialize_into(options, &mut cursor, &self) {
                    panic!("Bincode serialization error: {}", err);
                };
                assert_eq!(cursor.position(), size as u64);
            }
        }

        sizes.heap += size;
        write_reference::<Bytes, B>(size, sizes.heap, sizes.heap, sizes.stack, buffer)?;
        sizes.stack += reference_size::<Bytes>();
        Ok(())
    }

    #[inline(always)]
    fn size_hint(&self) -> Option<Sizes> {
        None
    }
}

impl<'de, T> Deserialize<'de, Bincode> for T
where
    T: serde::Deserialize<'de>,
{
    #[inline]
    fn deserialize(de: Deserializer<'de>) -> Result<Self, DeserializeError>
    where
        Self: Sized,
    {
        let de = de.deref::<Bytes>()?;

        let options = bincode::config::DefaultOptions::new();
        let mut de = bincode::de::Deserializer::from_slice(de.read_all_bytes(), options);

        match <T as serde::Deserialize<'de>>::deserialize(&mut de) {
            Ok(value) => Ok(value),
            Err(_err) => Err(DeserializeError::Incompatible),
        }
    }

    #[inline]
    fn deserialize_in_place(&mut self, de: Deserializer<'de>) -> Result<(), DeserializeError> {
        let de = de.deref::<Bytes>()?;

        let options = bincode::config::DefaultOptions::new();
        let mut de = bincode::de::Deserializer::from_slice(de.read_all_bytes(), options);

        match <T as serde::Deserialize<'de>>::deserialize_in_place(&mut de, self) {
            Ok(()) => Ok(()),
            Err(_err) => Err(DeserializeError::Incompatible),
        }
    }
}

/// A formula that can be used to serialize and deserialize data
/// using [`bincode`] crate.
///
/// Only one specified type can be used with this formula.
/// This helps avoid accidental deserialization of wrong type.
///
/// If type is not serializable with `bincode` crate it will cause a panic.
/// Deserializing non-compatible type will cause deserialization error.
pub struct Bincoded<T>(PhantomData<fn(&T) -> &T>);

impl<T> Formula for Bincoded<T> {
    const MAX_STACK_SIZE: Option<usize> = Some(size_of::<[FixedUsizeType; 2]>());
    const EXACT_SIZE: bool = true;
    const HEAPLESS: bool = false;
}

impl<T> Serialize<Bincoded<T>> for T
where
    T: serde::Serialize,
{
    #[inline(always)]
    fn serialize<B>(self, sizes: &mut Sizes, buffer: B) -> Result<(), B::Error>
    where
        B: Buffer,
    {
        <T as Serialize<Bincode>>::serialize(self, sizes, buffer)
    }

    #[inline(always)]
    fn size_hint(&self) -> Option<Sizes> {
        <T as Serialize<Bincode>>::size_hint(self)
    }
}

impl<'de, T> Deserialize<'de, Bincoded<T>> for T
where
    T: serde::Deserialize<'de>,
{
    #[inline(always)]
    fn deserialize(de: Deserializer<'de>) -> Result<Self, DeserializeError>
    where
        Self: Sized,
    {
        <T as Deserialize<'de, Bincode>>::deserialize(de)
    }

    #[inline(always)]
    fn deserialize_in_place(&mut self, de: Deserializer<'de>) -> Result<(), DeserializeError> {
        <T as Deserialize<'de, Bincode>>::deserialize_in_place(self, de)
    }
}