rapira 0.12.6

serialization library like borsh, bincode and speedy
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

use crate::{Rapira, RapiraFlags, Result};

#[inline]
pub fn size<T: Rapira>(item: &T) -> usize {
    match T::STATIC_SIZE {
        Some(s) => s,
        None => item.size(),
    }
}

pub fn write_to_array<const N: usize, T: Rapira>(item: &T, bytes: &mut [u8; N]) {
    assert_eq!(N, T::STATIC_SIZE.unwrap());
    item.convert_to_bytes(bytes, &mut 0);
}

/// serialize obect and return vec of bytes
#[cfg(feature = "alloc")]
pub fn serialize<T: Rapira>(item: &T) -> Vec<u8> {
    let value_size = size(item);
    let mut bytes: Vec<u8> = vec![0u8; value_size];
    item.convert_to_bytes(&mut bytes, &mut 0);
    bytes
}

/// extend vec of bytes with serialized object
#[cfg(feature = "alloc")]
pub fn extend_vec<T: Rapira>(item: &T, bytes: &mut Vec<u8>) {
    let value_size = size(item);
    let mut cursor = bytes.len();
    bytes.resize(cursor + value_size, 0);
    item.convert_to_bytes(bytes, &mut cursor);
}

/// write to vec of bytes with serialized object
#[cfg(feature = "alloc")]
pub fn write_to_vec<T: Rapira>(item: &T, bytes: &mut Vec<u8>) {
    let value_size = size(item);
    let len = bytes.len();
    if len < value_size {
        bytes.resize(value_size, 0);
    }
    item.convert_to_bytes(bytes, &mut 0);
}

/// Check oversize vec and other items with capacity initialization
/// (max memory limit attack...)
/// check cursor oveflow,
/// check utf-8 strings, float numbers, non zero numbers and others...
pub fn check_bytes<T>(bytes: &[u8]) -> Result<()>
where
    T: Rapira + Sized,
{
    let mut bytes = bytes;
    T::check_bytes(&mut bytes)
}

/// use `deserialize` function to read data to slice
pub fn read_to<T: Rapira>(mut bytes: &[u8], mut iter: impl Extend<T>) -> Result<()> {
    while !bytes.is_empty() {
        let item = T::from_slice(&mut bytes)?;
        iter.extend(Some(item));
    }
    Ok(())
}

// #[cfg(feature = "std")]
// pub fn encode_to_writer(item: &impl Rapira, mut writer: impl std::io::Write) -> Result<()> {
//     let value_size = size(item);
//     let mut bytes = vec![0u8; value_size];
//     item.convert_to_bytes(&mut bytes, &mut 0);
//     writer.write_all(&bytes).map_err(crate::RapiraError::from)?;
//     Ok(())
// }

// #[cfg(feature = "std")]
// pub fn decode_from_reader<T: Rapira>(mut reader: impl std::io::Read) -> Result<T> {
//     let mut bytes = Vec::new();
//     reader
//         .read_to_end(&mut bytes)
//         .map_err(crate::RapiraError::from)?;
//     deserialize(&bytes)
// }

/// Check oversize vec and other items with capacity initialization
/// with MaxCapacity trait
/// (max memory limit attack...)
///
/// Check cursor oveflow,
/// and check utf-8 strings, float numbers, non zero numbers and others...
pub fn deserialize<T>(mut bytes: &[u8]) -> Result<T>
where
    T: Rapira + Sized,
{
    T::from_slice(&mut bytes)
}

/// Deserialize with schema version awareness.
/// Version is stored externally (e.g. in DB metadata), not in the serialized data.
pub fn deserialize_versioned<T>(mut bytes: &[u8], version: u8) -> Result<T>
where
    T: Rapira + Sized,
{
    T::from_slice_versioned(&mut bytes, version)
}

/// # Safety
///
/// NOT check oversize vec and other items with capacity initialization
/// (max memory limit attack...)
/// NOT check utf-8 strings, float numbers, non zero numbers,
/// Arrayvec len and others...
///
/// but check cursor oveflow
/// Another way - data maybe not correct, but not read from other memory
pub unsafe fn deser_unchecked<T>(mut bytes: &[u8]) -> Result<T>
where
    T: Rapira + Sized,
{
    unsafe { T::from_slice_unchecked(&mut bytes) }
}

/// # Safety
///
/// This is extremally unsafe and UB maybe...
/// Call only after check_bytes fn!
///
/// NOT check oversize vec and other items with capacity initialization
/// (max memory limit attack...)
/// NOT check utf-8 strings, float numbers, non zero numbers and others...
/// NOT check cursor oveflow
pub unsafe fn deser_unsafe<T>(mut bytes: &[u8]) -> Result<T>
where
    T: Rapira + Sized,
{
    unsafe { T::from_slice_unsafe(&mut bytes) }
}

#[inline]
pub fn size_ctx<T: Rapira>(item: &T, flags: RapiraFlags) -> usize {
    match T::STATIC_SIZE {
        Some(s) => s,
        None => item.size_ctx(flags),
    }
}

/// Serialize with context flags.
#[cfg(feature = "alloc")]
pub fn serialize_ctx<T: Rapira>(item: &T, flags: RapiraFlags) -> Vec<u8> {
    let value_size = size_ctx(item, flags);
    let mut bytes: Vec<u8> = vec![0u8; value_size];
    item.convert_to_bytes_ctx(&mut bytes, &mut 0, flags);
    bytes
}

/// Deserialize with context flags.
pub fn deserialize_ctx<T: Rapira + Sized>(mut bytes: &[u8], flags: RapiraFlags) -> Result<T> {
    T::from_slice_ctx(&mut bytes, flags)
}