serde_beve/
headers.rs

1use crate::Value;
2
3pub const NULL: u8 = 0;
4pub const FALSE: u8 = 0b00001000;
5pub const TRUE: u8 = 0b00011000;
6
7pub const BF16: u8 = 0b00000001;
8pub const F16: u8 = 0b000100001;
9pub const F32: u8 = 0b01000001;
10pub const F64: u8 = 0b01100001;
11pub const F128: u8 = 0b10000001;
12
13pub const I8: u8 = 0b00001001;
14pub const I16: u8 = 0b00101001;
15pub const I32: u8 = 0b01001001;
16pub const I64: u8 = 0b01101001;
17pub const I128: u8 = 0b10001001;
18
19pub const U8: u8 = 0b00010001;
20pub const U16: u8 = 0b00110001;
21pub const U32: u8 = 0b01010001;
22pub const U64: u8 = 0b01110001;
23pub const U128: u8 = 0b10010001;
24
25pub const STRING: u8 = 0b00000010;
26
27pub const STRING_OBJECT: u8 = 0b00000011;
28
29pub const I8_OBJECT: u8 = 0b00001011;
30pub const I16_OBJECT: u8 = 0b00101011;
31pub const I32_OBJECT: u8 = 0b01001011;
32pub const I64_OBJECT: u8 = 0b01101011;
33pub const I128_OBJECT: u8 = 0b10001011;
34
35pub const U8_OBJECT: u8 = 0b00010011;
36pub const U16_OBJECT: u8 = 0b00110011;
37pub const U32_OBJECT: u8 = 0b01010011;
38pub const U64_OBJECT: u8 = 0b01110011;
39pub const U128_OBJECT: u8 = 0b10010011;
40
41pub const BF16_ARRAY: u8 = 0b00000100;
42pub const F16_ARRAY: u8 = 0b00100100;
43pub const F32_ARRAY: u8 = 0b01000100;
44pub const F64_ARRAY: u8 = 0b01100100;
45pub const F128_ARRAY: u8 = 0b10000100;
46
47pub const I8_ARRAY: u8 = 0b00001100;
48pub const I16_ARRAY: u8 = 0b00101100;
49pub const I32_ARRAY: u8 = 0b01001100;
50pub const I64_ARRAY: u8 = 0b01101100;
51pub const I128_ARRAY: u8 = 0b10001100;
52
53pub const U8_ARRAY: u8 = 0b00010100;
54pub const U16_ARRAY: u8 = 0b00110100;
55pub const U32_ARRAY: u8 = 0b01010100;
56pub const U64_ARRAY: u8 = 0b01110100;
57pub const U128_ARRAY: u8 = 0b10010100;
58
59pub const BOOL_ARRAY: u8 = 0b00011100;
60pub const STRING_ARRAY: u8 = 0b00111100;
61pub const GENERIC_ARRAY: u8 = 0b00000101;
62
63pub const DELIMITER: u8 = 0b00000110;
64pub const TAG: u8 = 0b00001110;
65pub const MATRIX: u8 = 0b00010110;
66pub const COMPLEX: u8 = 0b00011110;
67
68pub const RESERVED: u8 = 0b00000111;
69
70pub const fn header_name(header: u8) -> &'static str {
71    match header {
72        NULL => "null",
73        FALSE | TRUE => "boolean",
74
75        BF16 => "brain float",
76        F16 => "16-bit float",
77        F32 => "32-bit float",
78        F64 => "64-bit float",
79        F128 => "128-bit float",
80
81        I8 => "8-bit integer",
82        I16 => "16-bit integer",
83        I32 => "32-bit integer",
84        I64 => "64-bit integer",
85        I128 => "128-bit integer",
86
87        U8 => "8-bit unsigned integer",
88        U16 => "16-bit unsigned integer",
89        U32 => "32-bit unsigned integer",
90        U64 => "64-bit unsigned integer",
91        U128 => "128-bit unsigned integer",
92
93        STRING => "string",
94
95        STRING_OBJECT => "string-keyed object",
96
97        I8_OBJECT => "8-bit integer-keyed object",
98        I16_OBJECT => "16-bit integer-keyed object",
99        I32_OBJECT => "32-bit integer-keyed object",
100        I64_OBJECT => "64-bit integer-keyed object",
101        I128_OBJECT => "128-bit integer-keyed object",
102
103        U8_OBJECT => "unsigned 8-bit integer-keyed object",
104        U16_OBJECT => "unsigned 16-bit integer-keyed object",
105        U32_OBJECT => "unsigned 32-bit integer-keyed object",
106        U64_OBJECT => "unsigned 64-bit integer-keyed object",
107        U128_OBJECT => "unsigned 128-bit integer-keyed object",
108
109        BF16_ARRAY => "array of brain floats",
110        F16_ARRAY => "array of 16-bit floats",
111        F32_ARRAY => "array of 32-bit floats",
112        F64_ARRAY => "array of 64-bit floats",
113        F128_ARRAY => "array of 128-bit floats",
114
115        I8_ARRAY => "array of 8-bit integers",
116        I16_ARRAY => "array of 16-bit integers",
117        I32_ARRAY => "array of 32-bit integers",
118        I64_ARRAY => "array of 64-bit integers",
119        I128_ARRAY => "array of 128-bit integers",
120
121        U8_ARRAY => "array of 8-bit unsigned integers",
122        U16_ARRAY => "array of 16-bit unsigned integers",
123        U32_ARRAY => "array of 32-bit unsigned integers",
124        U64_ARRAY => "array of 64-bit unsigned integers",
125        U128_ARRAY => "array of 128-bit unsigned integers",
126
127        BOOL_ARRAY => "array of booleans",
128        STRING_ARRAY => "array of strings",
129        GENERIC_ARRAY => "generic array",
130
131        DELIMITER => "data delimiter",
132        TAG => "type tag",
133        MATRIX => "matrix",
134        COMPLEX => "complex number",
135
136        RESERVED => "reserved",
137        _ => "unknown type",
138    }
139}
140
141#[derive(Debug, Clone, Copy, PartialEq, Eq)]
142pub enum ArrayKind {
143    Generic,
144    String,
145    Boolean,
146    I8,
147    I16,
148    I32,
149    I64,
150    I128,
151    U8,
152    U16,
153    U32,
154    U64,
155    U128,
156    BF16,
157    F16,
158    F32,
159    F64,
160    F128,
161    Complex,
162}
163
164impl From<&Value> for ArrayKind {
165    fn from(value: &Value) -> Self {
166        match value {
167            Value::I8(..) => Self::I8,
168            Value::I16(..) => Self::I16,
169            Value::I32(..) => Self::I32,
170            Value::I64(..) => Self::I64,
171            Value::I128(..) => Self::I128,
172            Value::U8(..) => Self::U8,
173            Value::U16(..) => Self::U16,
174            Value::U32(..) => Self::U32,
175            Value::U64(..) => Self::U64,
176            Value::U128(..) => Self::U128,
177            #[cfg(feature = "half")]
178            Value::BF16(..) => Self::BF16,
179            #[cfg(not(feature = "half"))]
180            Value::BF16 => Self::BF16,
181            #[cfg(feature = "half")]
182            Value::F16(..) => Self::F16,
183            #[cfg(not(feature = "half"))]
184            Value::F16 => Self::F16,
185            Value::F32(..) => Self::F32,
186            Value::F64(..) => Self::F64,
187            Value::F128 => Self::F128,
188            Value::Complex(..) => unreachable!(),
189            Value::String(..) => Self::String,
190            Value::True | Value::False => Self::Boolean,
191            _ => Self::Generic,
192        }
193    }
194}
195
196impl ArrayKind {
197    pub const fn header(self) -> u8 {
198        match self {
199            Self::Generic => GENERIC_ARRAY,
200            Self::String => STRING_ARRAY,
201            Self::Boolean => BOOL_ARRAY,
202            Self::I8 => I8_ARRAY,
203            Self::I16 => I16_ARRAY,
204            Self::I32 => I32_ARRAY,
205            Self::I64 => I64_ARRAY,
206            Self::I128 => I128_ARRAY,
207            Self::U8 => U8_ARRAY,
208            Self::U16 => U16_ARRAY,
209            Self::U32 => U32_ARRAY,
210            Self::U64 => U64_ARRAY,
211            Self::U128 => U128_ARRAY,
212            Self::BF16 => BF16_ARRAY,
213            Self::F16 => F16_ARRAY,
214            Self::F32 => F32_ARRAY,
215            Self::F64 => F64_ARRAY,
216            Self::F128 => F128,
217            Self::Complex => COMPLEX,
218        }
219    }
220}
221
222impl std::fmt::Display for ArrayKind {
223    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
224        match self {
225            Self::Generic => write!(f, "{}", header_name(GENERIC_ARRAY)),
226            Self::String => write!(f, "{}", header_name(STRING)),
227            Self::Boolean => write!(f, "{}", header_name(TRUE)),
228            Self::I8 => write!(f, "{}", header_name(I8)),
229            Self::I16 => write!(f, "{}", header_name(I16)),
230            Self::I32 => write!(f, "{}", header_name(I32)),
231            Self::I64 => write!(f, "{}", header_name(I64)),
232            Self::I128 => write!(f, "{}", header_name(I128)),
233            Self::U8 => write!(f, "{}", header_name(U8)),
234            Self::U16 => write!(f, "{}", header_name(U16)),
235            Self::U32 => write!(f, "{}", header_name(U32)),
236            Self::U64 => write!(f, "{}", header_name(U64)),
237            Self::U128 => write!(f, "{}", header_name(U128)),
238            Self::BF16 => write!(f, "{}", header_name(BF16)),
239            Self::F16 => write!(f, "{}", header_name(F16)),
240            Self::F32 => write!(f, "{}", header_name(F32)),
241            Self::F64 => write!(f, "{}", header_name(F64)),
242            Self::F128 => write!(f, "{}", header_name(F128)),
243            Self::Complex => write!(f, "{}", header_name(COMPLEX)),
244        }
245    }
246}
247
248#[derive(Debug, Clone, Copy, PartialEq, Eq)]
249pub enum ObjectKind {
250    U8,
251    U16,
252    U32,
253    U64,
254    U128,
255    I8,
256    I16,
257    I32,
258    I64,
259    I128,
260    String,
261}
262
263impl ObjectKind {
264    pub const fn header(self) -> u8 {
265        match self {
266            Self::U8 => U8_OBJECT,
267            Self::U16 => U16_OBJECT,
268            Self::U32 => U32_OBJECT,
269            Self::U64 => U64_OBJECT,
270            Self::U128 => U128_OBJECT,
271            Self::I8 => I8_OBJECT,
272            Self::I16 => I16_OBJECT,
273            Self::I32 => I32_OBJECT,
274            Self::I64 => I64_OBJECT,
275            Self::I128 => I128_OBJECT,
276            Self::String => STRING_OBJECT,
277        }
278    }
279}
280
281impl std::fmt::Display for ObjectKind {
282    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
283        match self {
284            Self::U8 => write!(f, "{}", header_name(U8)),
285            Self::U16 => write!(f, "{}", header_name(U16)),
286            Self::U32 => write!(f, "{}", header_name(U32)),
287            Self::U64 => write!(f, "{}", header_name(U64)),
288            Self::U128 => write!(f, "{}", header_name(U128)),
289            Self::I8 => write!(f, "{}", header_name(I8)),
290            Self::I16 => write!(f, "{}", header_name(I16)),
291            Self::I32 => write!(f, "{}", header_name(I32)),
292            Self::I64 => write!(f, "{}", header_name(I64)),
293            Self::I128 => write!(f, "{}", header_name(I128)),
294            Self::String => write!(f, "{}", header_name(STRING)),
295        }
296    }
297}
298
299impl TryFrom<&Value> for ObjectKind {
300    type Error = crate::Error;
301
302    fn try_from(value: &Value) -> Result<Self, Self::Error> {
303        Ok(match value {
304            Value::I8(..) => Self::I8,
305            Value::I16(..) => Self::I16,
306            Value::I32(..) => Self::I32,
307            Value::I64(..) => Self::I64,
308            Value::I128(..) => Self::I128,
309            Value::U8(..) => Self::U8,
310            Value::U16(..) => Self::U16,
311            Value::U32(..) => Self::U32,
312            Value::U64(..) => Self::U64,
313            Value::U128(..) => Self::U128,
314            Value::String(..) => Self::String,
315            _ => return Err(crate::Error::InvalidKey),
316        })
317    }
318}
319
320pub const NUM_TYPE_MASK: u8 = 0b11111000;
321
322// Just the bits representing the size of the number
323pub const I8_HEADER: u8 = I8 & NUM_TYPE_MASK;
324pub const I16_HEADER: u8 = I16 & NUM_TYPE_MASK;
325pub const I32_HEADER: u8 = I32 & NUM_TYPE_MASK;
326pub const I64_HEADER: u8 = I64 & NUM_TYPE_MASK;
327pub const I128_HEADER: u8 = I128 & NUM_TYPE_MASK;
328pub const U8_HEADER: u8 = U8 & NUM_TYPE_MASK;
329pub const U16_HEADER: u8 = U16 & NUM_TYPE_MASK;
330pub const U32_HEADER: u8 = U32 & NUM_TYPE_MASK;
331pub const U64_HEADER: u8 = U64 & NUM_TYPE_MASK;
332pub const U128_HEADER: u8 = U128 & NUM_TYPE_MASK;
333pub const F32_HEADER: u8 = F32 & NUM_TYPE_MASK;
334pub const F64_HEADER: u8 = F64 & NUM_TYPE_MASK;
serde_beve/headers.rs

serde_beve/
headers.rs
