serde_beve/
value.rs

1use std::collections::HashMap;
2
3use serde::{
4    Deserialize,
5    de::VariantAccess,
6    ser::{SerializeMap, SerializeSeq},
7};
8
9use crate::{Error, error::SpecialType, headers::*};
10use serde::Serialize;
11
12#[derive(PartialEq)]
13/// An intermediate representation of values used during serialization.
14///
15/// This is a nearly 1:1 mapping to the `HEADER | VALUE` format in which BEVE values are encoded.
16///
17/// Objects are represented as a vector of key-value pairs, and strings are represented as their
18/// bytes.
19pub enum Value {
20    Null,
21    True,
22    False,
23    #[cfg(feature = "half")]
24    /// <div class="warning">
25    /// When the <code>half</code> feature is disabled, this variant will carry no payload.
26    /// </div>
27    BF16(half::bf16),
28    #[cfg(not(feature = "half"))]
29    BF16,
30    #[cfg(feature = "half")]
31    /// <div class="warning">
32    /// When the <code>half</code> feature is disabled, this variant will carry no payload.
33    /// </div>
34    F16(half::f16),
35    #[cfg(not(feature = "half"))]
36    F16,
37    F32(f32),
38    F64(f64),
39    F128,
40
41    I8(i8),
42    I16(i16),
43    I32(i32),
44    I64(i64),
45    I128(i128),
46
47    U8(u8),
48    U16(u16),
49    U32(u32),
50    U64(u64),
51    U128(u128),
52
53    String(Vec<u8>),
54
55    StringObject(Vec<(Vec<u8>, Value)>),
56
57    I8Object(Vec<(i8, Value)>),
58    I16Object(Vec<(i16, Value)>),
59    I32Object(Vec<(i32, Value)>),
60    I64Object(Vec<(i64, Value)>),
61    I128Object(Vec<(i128, Value)>),
62
63    U8Object(Vec<(u8, Value)>),
64    U16Object(Vec<(u16, Value)>),
65    U32Object(Vec<(u32, Value)>),
66    U64Object(Vec<(u64, Value)>),
67    U128Object(Vec<(u128, Value)>),
68
69    #[cfg(feature = "half")]
70    BF16Array(Vec<half::bf16>),
71    #[cfg(not(feature = "half"))]
72    BF16Array,
73    #[cfg(feature = "half")]
74    F16Array(Vec<half::f16>),
75    #[cfg(not(feature = "half"))]
76    F16Array,
77    F32Array(Vec<f32>),
78    F64Array(Vec<f64>),
79    F128Array,
80
81    I8Array(Vec<i8>),
82    I16Array(Vec<i16>),
83    I32Array(Vec<i32>),
84    I64Array(Vec<i64>),
85    I128Array(Vec<i128>),
86
87    U8Array(Vec<u8>),
88    U16Array(Vec<u16>),
89    U32Array(Vec<u32>),
90    U64Array(Vec<u64>),
91    U128Array(Vec<u128>),
92
93    /// Note that field 1 contains [`u8`]s rather than [`bool`]s. This is because it is meant to
94    /// be written directly to a writer during serialization, where each bit within each byte
95    /// represents a true or false value.
96    BoolArray(usize, Vec<u8>),
97    StringArray(Vec<Vec<u8>>),
98    GenericArray(Vec<Value>),
99
100    Delimiter,
101    // Box for indirection
102    // I hate it here
103    Tag(usize, Box<Value>),
104    Matrix {
105        layout: MatrixLayout,
106        /// **Must be a typed array of integers.**
107        extents: Box<Value>,
108        /// **Must be a typed array of numbers.**
109        value: Box<Value>,
110    },
111    Complex(ComplexNumber),
112    Reserved,
113}
114
115macro_rules! impl_from_primitive {
116    ( $( $ty:ty => $variant:ident $(| $conv:expr)? ),* $(,)? ) => {
117        $(
118            impl From<$ty> for Value {
119                #[inline]
120                fn from(value: $ty) -> Self {
121                    $(
122                        let value = $conv(value);
123                    )?
124                    Value::$variant(value)
125                }
126            }
127        )*
128    }
129}
130
131impl_from_primitive! {
132    i8 => I8,
133    i16 => I16,
134    i32 => I32,
135    i64 => I64,
136    i128 => I128,
137    u8 => U8,
138    u16 => U16,
139    u32 => U32,
140    u64 => U64,
141    u128 => U128,
142    f32 => F32,
143    f64 => F64,
144    String => String | |v: String| v.into_bytes(),
145    &str => String | |v: &str| v.as_bytes().to_vec(),
146}
147
148#[cfg(feature = "half")]
149impl_from_primitive! {
150    half::f16 => F16,
151    half::bf16 => BF16,
152}
153
154macro_rules! impl_from_array {
155    ( $( $ty:ty => $variant:ident $(| $conv:expr)? ),* $(,)? ) => {
156        $(
157            impl From<Vec<$ty>> for Value {
158                #[inline]
159                fn from(value: Vec<$ty>) -> Self {
160                    $(
161                        let value = $conv(value);
162                    )?
163                    Value::$variant(value)
164                }
165            }
166        )*
167    }
168}
169
170impl_from_array! {
171    i8 => I8Array,
172    i16 => I16Array,
173    i32 => I32Array,
174    i64 => I64Array,
175    i128 => I128Array,
176    u8 => U8Array,
177    u16 => U16Array,
178    u32 => U32Array,
179    u64 => U64Array,
180    u128 => U128Array,
181    f32 => F32Array,
182    f64 => F64Array,
183    &str => StringArray | |v: Vec<&str>| v.iter().map(|v| v.as_bytes().to_vec()).collect(),
184    String => StringArray | |v: Vec<String>| v.iter().map(|v| v.bytes().collect()).collect(),
185}
186
187#[cfg(feature = "half")]
188impl_from_array! {
189    half::f16 => F16Array,
190    half::bf16 => BF16Array,
191}
192
193macro_rules! impl_from_object {
194    ( $( $key:ty => $variant:ident $(| $conv:expr)? ),* $(,)? ) => {
195        $(
196            impl<T: Into<Value>> From<HashMap<$key, T>> for Value {
197                #[inline]
198                fn from(value: HashMap<$key, T>) -> Self {
199                    Value::$variant(
200                        value
201                            .into_iter()
202                            .map(|(k, v)| {
203                                $(
204                                    let k = $conv(k);
205                                )?
206                                (k, v.into())
207                            })
208                            .collect(),
209                    )
210                }
211            }
212        )*
213    }
214}
215
216impl_from_object! {
217    i8   => I8Object,
218    i16  => I16Object,
219    i32  => I32Object,
220    i64  => I64Object,
221    i128 => I128Object,
222    u8   => U8Object,
223    u16  => U16Object,
224    u32  => U32Object,
225    u64  => U64Object,
226    u128 => U128Object,
227    String => StringObject | |k: String| k.into_bytes(),
228    &str => StringObject | |k: &str| k.as_bytes().to_vec(),
229}
230
231impl From<()> for Value {
232    fn from(_value: ()) -> Self {
233        Value::Null
234    }
235}
236
237impl<T: Into<Value>> From<Option<T>> for Value {
238    fn from(value: Option<T>) -> Self {
239        match value {
240            Some(v) => v.into(),
241            None => Value::Null,
242        }
243    }
244}
245
246impl From<bool> for Value {
247    fn from(value: bool) -> Self {
248        if value { Value::True } else { Value::False }
249    }
250}
251
252impl From<Vec<bool>> for Value {
253    fn from(value: Vec<bool>) -> Self {
254        Value::BoolArray(
255            value.len(),
256            value
257                .chunks(8)
258                .map(|v| {
259                    let mut out = 0;
260                    for v in v {
261                        out <<= 1;
262                        if *v {
263                            out |= 1
264                        };
265                    }
266                    out
267                })
268                .collect(),
269        )
270    }
271}
272
273impl std::fmt::Debug for Value {
274    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
275        match self {
276            Self::Null => write!(f, "Null"),
277            Self::True => write!(f, "True"),
278            Self::False => write!(f, "False"),
279            #[cfg(feature = "half")]
280            Self::BF16(v) => f.debug_tuple("BF16").field(v).finish(),
281            #[cfg(not(feature = "half"))]
282            Self::BF16 => write!(f, "BF16"),
283            #[cfg(feature = "half")]
284            Self::F16(v) => f.debug_tuple("F16").field(v).finish(),
285            #[cfg(not(feature = "half"))]
286            Self::F16 => write!(f, "F16"),
287            Self::F32(v) => f.debug_tuple("F32").field(v).finish(),
288            Self::F64(v) => f.debug_tuple("F64").field(v).finish(),
289            Self::F128 => write!(f, "F128"),
290            Self::I8(v) => f.debug_tuple("I8").field(v).finish(),
291            Self::I16(v) => f.debug_tuple("I16").field(v).finish(),
292            Self::I32(v) => f.debug_tuple("I32").field(v).finish(),
293            Self::I64(v) => f.debug_tuple("I64").field(v).finish(),
294            Self::I128(v) => f.debug_tuple("I128").field(v).finish(),
295            Self::U8(v) => f.debug_tuple("U8").field(v).finish(),
296            Self::U16(v) => f.debug_tuple("U16").field(v).finish(),
297            Self::U32(v) => f.debug_tuple("U32").field(v).finish(),
298            Self::U64(v) => f.debug_tuple("U64").field(v).finish(),
299            Self::U128(v) => f.debug_tuple("U128").field(v).finish(),
300            Self::String(v) => f
301                .debug_tuple("String")
302                .field(&unsafe { std::str::from_utf8_unchecked(v) })
303                .finish(),
304            Self::StringObject(v) => {
305                write!(f, "StringObject ")?;
306                f.debug_map()
307                    .entries(
308                        v.iter()
309                            .map(|(k, v)| (unsafe { std::str::from_utf8_unchecked(k) }, v)),
310                    )
311                    .finish()
312            }
313            Self::I8Object(v) => {
314                write!(f, "I8Object ")?;
315                f.debug_map()
316                    .entries(v.iter().map(|(k, v)| (k, v)))
317                    .finish()
318            }
319            Self::I16Object(v) => {
320                write!(f, "I16Object ")?;
321                f.debug_map()
322                    .entries(v.iter().map(|(k, v)| (k, v)))
323                    .finish()
324            }
325            Self::I32Object(v) => {
326                write!(f, "I32Object ")?;
327                f.debug_map()
328                    .entries(v.iter().map(|(k, v)| (k, v)))
329                    .finish()
330            }
331            Self::I64Object(v) => {
332                write!(f, "I64Object ")?;
333                f.debug_map()
334                    .entries(v.iter().map(|(k, v)| (k, v)))
335                    .finish()
336            }
337            Self::I128Object(v) => {
338                write!(f, "I128Object ")?;
339                f.debug_map()
340                    .entries(v.iter().map(|(k, v)| (k, v)))
341                    .finish()
342            }
343            Self::U8Object(v) => {
344                write!(f, "U8Object ")?;
345                f.debug_map()
346                    .entries(v.iter().map(|(k, v)| (k, v)))
347                    .finish()
348            }
349            Self::U16Object(v) => {
350                write!(f, "U16Object ")?;
351                f.debug_map()
352                    .entries(v.iter().map(|(k, v)| (k, v)))
353                    .finish()
354            }
355            Self::U32Object(v) => {
356                write!(f, "U32Object ")?;
357                f.debug_map()
358                    .entries(v.iter().map(|(k, v)| (k, v)))
359                    .finish()
360            }
361            Self::U64Object(v) => {
362                write!(f, "U64Object ")?;
363                f.debug_map()
364                    .entries(v.iter().map(|(k, v)| (k, v)))
365                    .finish()
366            }
367            Self::U128Object(v) => {
368                write!(f, "U128Object ")?;
369                f.debug_map()
370                    .entries(v.iter().map(|(k, v)| (k, v)))
371                    .finish()
372            }
373            #[cfg(feature = "half")]
374            Self::F16Array(v) => f.debug_tuple("F16Array").field(v).finish(),
375            #[cfg(not(feature = "half"))]
376            Self::F16Array => write!(f, "F16Array"),
377            #[cfg(feature = "half")]
378            Self::BF16Array(v) => f.debug_tuple("BF16Array").field(v).finish(),
379            #[cfg(not(feature = "half"))]
380            Self::BF16Array => write!(f, "BF16Array"),
381            Self::F32Array(v) => f.debug_tuple("F32Array").field(v).finish(),
382            Self::F64Array(v) => f.debug_tuple("F64Array").field(v).finish(),
383            Self::F128Array => write!(f, "F128Array"),
384            Self::I8Array(v) => f.debug_tuple("I8Array").field(v).finish(),
385            Self::I16Array(v) => f.debug_tuple("I16Array").field(v).finish(),
386            Self::I32Array(v) => f.debug_tuple("I32Array").field(v).finish(),
387            Self::I64Array(v) => f.debug_tuple("I64Array").field(v).finish(),
388            Self::I128Array(v) => f.debug_tuple("I128Array").field(v).finish(),
389            Self::U8Array(v) => f.debug_tuple("U8Array").field(v).finish(),
390            Self::U16Array(v) => f.debug_tuple("U16Array").field(v).finish(),
391            Self::U32Array(v) => f.debug_tuple("U32Array").field(v).finish(),
392            Self::U64Array(v) => f.debug_tuple("U64Array").field(v).finish(),
393            Self::U128Array(v) => f.debug_tuple("U128Array").field(v).finish(),
394
395            Self::BoolArray(len, v) => f
396                .debug_tuple("BoolArray")
397                .field(
398                    &v.iter()
399                        .flat_map(|v| {
400                            let mut out = [false; 8];
401                            for (shift, item) in out.iter_mut().enumerate() {
402                                *item = v >> shift & 1 == 1;
403                            }
404                            out
405                        })
406                        .take(*len)
407                        .collect::<Vec<_>>(),
408                )
409                .finish(),
410            Self::StringArray(v) => f
411                .debug_tuple("StringArray")
412                .field(
413                    &v.iter()
414                        .map(|v| unsafe { std::str::from_utf8_unchecked(v) })
415                        .collect::<Vec<_>>(),
416                )
417                .finish(),
418            Self::GenericArray(v) => f.debug_tuple("GenericArray").field(v).finish(),
419            Self::Delimiter => write!(f, "Delimiter"),
420            Self::Tag(i, v) => f.debug_tuple("Tag").field(i).field(v).finish(),
421            Self::Matrix {
422                layout,
423                extents,
424                value,
425            } => f
426                .debug_struct("Matrix")
427                .field("layout", layout)
428                .field("extents", extents)
429                .field("value", value)
430                .finish(),
431            Self::Complex(c) => f.debug_tuple("Complex").field(c).finish(),
432            Self::Reserved => write!(f, "Reserved"),
433        }
434    }
435}
436
437#[derive(Debug, PartialEq, Eq, Serialize)]
438pub enum MatrixLayout {
439    #[serde(rename = "layout_left")]
440    Left,
441    #[serde(rename = "layout_right")]
442    Right,
443}
444
445#[derive(Debug, PartialEq)]
446/// Both the real and imaginary parts of a complex number **must be of the same type**, and
447/// obviously **must be numbers**.
448pub enum ComplexNumber {
449    Single((Box<Value>, Box<Value>)),
450    Array(Vec<(Box<Value>, Box<Value>)>),
451}
452
453impl Value {
454    pub fn header(&self) -> u8 {
455        match self {
456            Self::Null => NULL,
457            Self::True => TRUE,
458            Self::False => FALSE,
459
460            Self::BF16 { .. } => BF16,
461            Self::F16 { .. } => F16,
462            Self::F32(..) => F32,
463            Self::F64(..) => F64,
464            Self::F128 => F128,
465
466            Self::I8(..) => I8,
467            Self::I16(..) => I16,
468            Self::I32(..) => I32,
469            Self::I64(..) => I64,
470            Self::I128(..) => I128,
471
472            Self::U8(..) => U8,
473            Self::U16(..) => U16,
474            Self::U32(..) => U32,
475            Self::U64(..) => U64,
476            Self::U128(..) => U128,
477
478            Self::String(..) => STRING,
479
480            Self::StringObject(..) => STRING_OBJECT,
481
482            Self::I8Object(..) => I8_OBJECT,
483            Self::I16Object(..) => I16_OBJECT,
484            Self::I32Object(..) => I32_OBJECT,
485            Self::I64Object(..) => I64_OBJECT,
486            Self::I128Object(..) => I128_OBJECT,
487
488            Self::U8Object(..) => U8_OBJECT,
489            Self::U16Object(..) => U16_OBJECT,
490            Self::U32Object(..) => U32_OBJECT,
491            Self::U64Object(..) => U64_OBJECT,
492            Self::U128Object(..) => U128_OBJECT,
493
494            Self::BF16Array { .. } => BF16_ARRAY,
495            Self::F16Array { .. } => F16_ARRAY,
496            Self::F32Array(..) => F32_ARRAY,
497            Self::F64Array(..) => F64_ARRAY,
498            Self::F128Array => F128_ARRAY,
499
500            Self::I8Array(..) => I8_ARRAY,
501            Self::I16Array(..) => I16_ARRAY,
502            Self::I32Array(..) => I32_ARRAY,
503            Self::I64Array(..) => I64_ARRAY,
504            Self::I128Array(..) => I128_ARRAY,
505
506            Self::U8Array(..) => U8_ARRAY,
507            Self::U16Array(..) => U16_ARRAY,
508            Self::U32Array(..) => U32_ARRAY,
509            Self::U64Array(..) => U64_ARRAY,
510            Self::U128Array(..) => U128_ARRAY,
511
512            Self::BoolArray(..) => BOOL_ARRAY,
513            Self::StringArray(..) => STRING_ARRAY,
514            Self::GenericArray(..) => GENERIC_ARRAY,
515
516            Self::Delimiter => DELIMITER,
517            Self::Tag(..) => TAG,
518            Self::Matrix { .. } => MATRIX,
519            Self::Complex(..) => COMPLEX,
520            Self::Reserved => RESERVED,
521        }
522    }
523}
524
525impl std::fmt::Display for Value {
526    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
527        write!(f, "{}", header_name(self.header()))
528    }
529}
530
531impl Serialize for Value {
532    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
533    where
534        S: serde::Serializer,
535    {
536        fn serialize_map<S: serde::Serializer, K: Serialize, V: Serialize>(
537            s: S,
538            map: &[(K, V)],
539        ) -> Result<S::Ok, S::Error> {
540            let mut m = s.serialize_map(Some(map.len()))?;
541            for (k, v) in map {
542                m.serialize_entry(k, v)?;
543            }
544            m.end()
545        }
546
547        fn serialize_seq<S: serde::Serializer, T: Serialize>(
548            s: S,
549            seq: &[T],
550        ) -> Result<S::Ok, S::Error> {
551            let mut s = s.serialize_seq(Some(seq.len()))?;
552            for v in seq {
553                s.serialize_element(v)?;
554            }
555            s.end()
556        }
557
558        match self {
559            Self::Null => serializer.serialize_unit(),
560            Self::True => serializer.serialize_bool(true),
561            Self::False => serializer.serialize_bool(false),
562
563            #[cfg(feature = "half")]
564            Self::F16(v) => serializer.serialize_f32(v.to_f32()),
565            #[cfg(not(feature = "half"))]
566            Self::F16 => Err(serde::ser::Error::custom(Error::UnsupportedDataType(
567                SpecialType::HalfFloat,
568            ))),
569            #[cfg(feature = "half")]
570            Self::BF16(v) => serializer.serialize_f32(v.to_f32()),
571            #[cfg(not(feature = "half"))]
572            Self::BF16 => Err(serde::ser::Error::custom(Error::UnsupportedDataType(
573                SpecialType::BrainFloat,
574            ))),
575            Self::F32(v) => serializer.serialize_f32(*v),
576            Self::F64(v) => serializer.serialize_f64(*v),
577            Self::F128 => Err(serde::ser::Error::custom(Error::UnsupportedDataType(
578                SpecialType::F128,
579            ))),
580
581            Self::I8(v) => serializer.serialize_i8(*v),
582            Self::I16(v) => serializer.serialize_i16(*v),
583            Self::I32(v) => serializer.serialize_i32(*v),
584            Self::I64(v) => serializer.serialize_i64(*v),
585            Self::I128(v) => serializer.serialize_i128(*v),
586
587            Self::U8(v) => serializer.serialize_u8(*v),
588            Self::U16(v) => serializer.serialize_u16(*v),
589            Self::U32(v) => serializer.serialize_u32(*v),
590            Self::U64(v) => serializer.serialize_u64(*v),
591            Self::U128(v) => serializer.serialize_u128(*v),
592
593            Self::String(v) => {
594                serializer.serialize_str(std::str::from_utf8(v).map_err(serde::ser::Error::custom)?)
595            }
596
597            Self::StringObject(v) => serialize_map(serializer, v),
598            Self::I8Object(v) => serialize_map(serializer, v),
599            Self::I16Object(v) => serialize_map(serializer, v),
600            Self::I32Object(v) => serialize_map(serializer, v),
601            Self::I64Object(v) => serialize_map(serializer, v),
602            Self::I128Object(v) => serialize_map(serializer, v),
603            Self::U8Object(v) => serialize_map(serializer, v),
604            Self::U16Object(v) => serialize_map(serializer, v),
605            Self::U32Object(v) => serialize_map(serializer, v),
606            Self::U64Object(v) => serialize_map(serializer, v),
607            Self::U128Object(v) => serialize_map(serializer, v),
608
609            #[cfg(feature = "half")]
610            Self::F16Array(v) => serialize_seq(
611                serializer,
612                &v.iter().copied().map(half::f16::to_f32).collect::<Vec<_>>(),
613            ),
614            #[cfg(not(feature = "half"))]
615            Self::F16Array => Err(serde::ser::Error::custom(Error::UnsupportedDataType(
616                SpecialType::HalfFloat,
617            ))),
618            #[cfg(feature = "half")]
619            Self::BF16Array(v) => serialize_seq(
620                serializer,
621                &v.iter()
622                    .copied()
623                    .map(half::bf16::to_f32)
624                    .collect::<Vec<_>>(),
625            ),
626            #[cfg(not(feature = "half"))]
627            Self::BF16Array => Err(serde::ser::Error::custom(Error::UnsupportedDataType(
628                SpecialType::BrainFloat,
629            ))),
630            Self::F32Array(v) => serialize_seq(serializer, v),
631            Self::F64Array(v) => serialize_seq(serializer, v),
632            Self::F128Array => Err(serde::ser::Error::custom(Error::UnsupportedDataType(
633                SpecialType::F128,
634            ))),
635
636            Self::I8Array(v) => serialize_seq(serializer, v),
637            Self::I16Array(v) => serialize_seq(serializer, v),
638            Self::I32Array(v) => serialize_seq(serializer, v),
639            Self::I64Array(v) => serialize_seq(serializer, v),
640            Self::I128Array(v) => serialize_seq(serializer, v),
641
642            Self::U8Array(v) => serialize_seq(serializer, v),
643            Self::U16Array(v) => serialize_seq(serializer, v),
644            Self::U32Array(v) => serialize_seq(serializer, v),
645            Self::U64Array(v) => serialize_seq(serializer, v),
646            Self::U128Array(v) => serialize_seq(serializer, v),
647
648            Self::BoolArray(len, v) => serialize_seq(
649                serializer,
650                &v.iter()
651                    .flat_map(|v| {
652                        let mut out = [false; 8];
653                        for (shift, item) in out.iter_mut().enumerate() {
654                            *item = v >> shift & 1 == 1;
655                        }
656                        out
657                    })
658                    .take(*len)
659                    .collect::<Vec<_>>(),
660            ),
661
662            Self::StringArray(v) => serialize_seq(
663                serializer,
664                &v.iter()
665                    .map(|v| std::str::from_utf8(v).map_err(serde::ser::Error::custom))
666                    .collect::<Result<Vec<_>, _>>()?,
667            ),
668
669            Self::GenericArray(v) => serialize_seq(serializer, v),
670
671            Self::Tag(i, v) => serializer.serialize_newtype_variant("", *i as u32, "", v),
672
673            Self::Delimiter => Err(serde::ser::Error::custom(
674                "Delimiter can't be serialized with serde",
675            )),
676
677            Self::Matrix {
678                layout,
679                extents,
680                value,
681            } => {
682                let mut map = serializer.serialize_map(Some(3))?;
683                map.serialize_entry("layout", layout)?;
684                if matches!(
685                    **extents,
686                    Self::I8Array(_)
687                        | Self::I16Array(_)
688                        | Self::I32Array(_)
689                        | Self::I64Array(_)
690                        | Self::I128Array(_)
691                        | Self::U8Array(_)
692                        | Self::U16Array(_)
693                        | Self::U32Array(_)
694                        | Self::U64Array(_)
695                        | Self::U128Array(_)
696                ) {
697                    map.serialize_entry("extents", extents)?;
698                } else {
699                    return Err(serde::ser::Error::custom(
700                        "Matrix extents must be a typed array of integers",
701                    ));
702                }
703                match **value {
704                    Self::F32Array(..)
705                    | Self::F64Array(..)
706                    | Self::I8Array(..)
707                    | Self::I16Array(..)
708                    | Self::I32Array(..)
709                    | Self::I64Array(..)
710                    | Self::I128Array(..)
711                    | Self::U8Array(..)
712                    | Self::U16Array(..)
713                    | Self::U32Array(..)
714                    | Self::U64Array(..)
715                    | Self::U128Array(..) => {
716                        map.serialize_entry("value", value)?;
717                    }
718                    #[cfg(feature = "half")]
719                    Self::BF16Array(..) => {
720                        map.serialize_entry("value", value)?;
721                    }
722                    #[cfg(not(feature = "half"))]
723                    Self::BF16Array => {
724                        return Err(serde::ser::Error::custom(Error::UnsupportedDataType(
725                            SpecialType::BrainFloat,
726                        )));
727                    }
728                    #[cfg(feature = "half")]
729                    Self::F16Array(..) => {
730                        map.serialize_entry("value", value)?;
731                    }
732                    #[cfg(not(feature = "half"))]
733                    Self::F16Array => {
734                        return Err(serde::ser::Error::custom(Error::UnsupportedDataType(
735                            SpecialType::HalfFloat,
736                        )));
737                    }
738                    Self::F128Array => {
739                        return Err(serde::ser::Error::custom(
740                            crate::Error::UnsupportedDataType(crate::error::SpecialType::F128),
741                        ));
742                    }
743
744                    _ => {
745                        return Err(serde::ser::Error::custom(
746                            "Matrix value must be a typed array of numbers",
747                        ));
748                    }
749                }
750                map.end()
751            }
752            Self::Complex(c) => match c {
753                ComplexNumber::Single((re, im)) => match (re.as_ref(), im.as_ref()) {
754                    (Value::F32(_), Value::F32(_))
755                    | (Value::F64(_), Value::F64(_))
756                    | (Value::I8(_), Value::I8(_))
757                    | (Value::I16(_), Value::I16(_))
758                    | (Value::I32(_), Value::I32(_))
759                    | (Value::I64(_), Value::I64(_))
760                    | (Value::I128(_), Value::I128(_))
761                    | (Value::U8(_), Value::U8(_))
762                    | (Value::U16(_), Value::U16(_))
763                    | (Value::U32(_), Value::U32(_))
764                    | (Value::U64(_), Value::U64(_))
765                    | (Value::U128(_), Value::U128(_)) => {
766                        let mut seq = serializer.serialize_seq(Some(2))?;
767                        seq.serialize_element(re)?;
768                        seq.serialize_element(im)?;
769                        seq.end()
770                    }
771                    _ => Err(serde::ser::Error::custom(
772                        "Complex number must be a pair of numbers of the same type",
773                    )),
774                },
775                ComplexNumber::Array(v) => {
776                    let mut seq = serializer.serialize_seq(Some(v.len()))?;
777                    for (re, im) in v {
778                        match (re.as_ref(), im.as_ref()) {
779                            (Value::F32(_), Value::F32(_))
780                            | (Value::F64(_), Value::F64(_))
781                            | (Value::I8(_), Value::I8(_))
782                            | (Value::I16(_), Value::I16(_))
783                            | (Value::I32(_), Value::I32(_))
784                            | (Value::I64(_), Value::I64(_))
785                            | (Value::I128(_), Value::I128(_))
786                            | (Value::U8(_), Value::U8(_))
787                            | (Value::U16(_), Value::U16(_))
788                            | (Value::U32(_), Value::U32(_))
789                            | (Value::U64(_), Value::U64(_))
790                            | (Value::U128(_), Value::U128(_)) => {
791                                seq.serialize_element(&[re, im])?;
792                            }
793                            _ => {
794                                return Err(serde::ser::Error::custom(
795                                    "Complex number must be a pair of numbers of the same type",
796                                ));
797                            }
798                        }
799                    }
800                    seq.end()
801                }
802            },
803            Self::Reserved => Err(serde::ser::Error::custom(
804                "Reserved value can't be serialized with serde",
805            )),
806        }
807    }
808}
809
810impl<'de> Deserialize<'de> for Value {
811    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
812    where
813        D: serde::Deserializer<'de>,
814    {
815        struct ValueVisitor;
816
817        macro_rules! visit_number {
818            ($fn: ident, $ty:ty, $variant:ident) => {
819                fn $fn<E>(self, v: $ty) -> Result<Self::Value, E>
820                where
821                    E: serde::de::Error,
822                {
823                    Ok(Value::$variant(v))
824                }
825            };
826        }
827
828        impl<'de> serde::de::Visitor<'de> for ValueVisitor {
829            type Value = Value;
830
831            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
832                write!(formatter, "a BEVE value")
833            }
834
835            visit_number!(visit_i8, i8, I8);
836            visit_number!(visit_i16, i16, I16);
837            visit_number!(visit_i32, i32, I32);
838            visit_number!(visit_i64, i64, I64);
839            visit_number!(visit_i128, i128, I128);
840            visit_number!(visit_u8, u8, U8);
841            visit_number!(visit_u16, u16, U16);
842            visit_number!(visit_u32, u32, U32);
843            visit_number!(visit_u64, u64, U64);
844            visit_number!(visit_u128, u128, U128);
845            visit_number!(visit_f32, f32, F32);
846            visit_number!(visit_f64, f64, F64);
847
848            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
849            where
850                E: serde::de::Error,
851            {
852                Ok(v.into())
853            }
854
855            fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
856            where
857                E: serde::de::Error,
858            {
859                self.visit_str(&v.to_string())
860            }
861
862            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
863            where
864                E: serde::de::Error,
865            {
866                Ok(Value::String(v.as_bytes().to_vec()))
867            }
868
869            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
870            where
871                E: serde::de::Error,
872            {
873                Ok(Value::String(v.into_bytes()))
874            }
875
876            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
877            where
878                E: serde::de::Error,
879            {
880                Ok(Value::U8Array(v.to_vec()))
881            }
882
883            fn visit_none<E>(self) -> Result<Self::Value, E>
884            where
885                E: serde::de::Error,
886            {
887                Ok(Value::Null)
888            }
889
890            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
891            where
892                D: serde::Deserializer<'de>,
893            {
894                deserializer.deserialize_any(self)
895            }
896
897            fn visit_unit<E>(self) -> Result<Self::Value, E>
898            where
899                E: serde::de::Error,
900            {
901                Ok(Value::Null)
902            }
903
904            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
905            where
906                D: serde::Deserializer<'de>,
907            {
908                deserializer.deserialize_any(self)
909            }
910
911            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
912            where
913                A: serde::de::SeqAccess<'de>,
914            {
915                let Some(first) = seq.next_element::<Value>()? else {
916                    return Ok(Value::GenericArray(vec![]));
917                };
918                let mut kind = ArrayKind::from(&first);
919                let mut out = vec![first];
920                while let Some(value) = seq.next_element::<Value>()? {
921                    if ArrayKind::from(&value) != kind {
922                        kind = ArrayKind::Generic;
923                    }
924
925                    out.push(value);
926                }
927
928                macro_rules! convert_array {
929                    ( $( $(#[$meta:meta])* $kind:ident => $array:ident ),* $(,)? | $( $(#[$other_meta:meta])* $other:ident => $other_val:expr ),* $(,)? ) => {
930                        match kind {
931                            $(
932                                $(#[$meta])*
933                                ArrayKind::$kind => Value::$array(
934                                    out.into_iter()
935                                        .map(|v| match v {
936                                            Value::$kind(v) => v,
937                                            _ => unreachable!(),
938                                        })
939                                        .collect(),
940                                ),
941                            )*
942                            $(
943                                $(#[$other_meta])*
944                                ArrayKind::$other => $other_val,
945                            )*
946                        }
947                    }
948                }
949
950                Ok(convert_array! {
951                    I8 => I8Array,
952                    I16 => I16Array,
953                    I32 => I32Array,
954                    I64 => I64Array,
955                    I128 => I128Array,
956                    U8 => U8Array,
957                    U16 => U16Array,
958                    U32 => U32Array,
959                    U64 => U64Array,
960                    U128 => U128Array,
961                    #[cfg(feature = "half")]
962                    BF16 => BF16Array,
963                    #[cfg(feature = "half")]
964                    F16 => F16Array,
965                    F32 => F32Array,
966                    F64 => F64Array,
967                    String => StringArray,
968                    |
969                    #[cfg(not(feature = "half"))]
970                    F16 => Value::F16,
971                    #[cfg(not(feature = "half"))]
972                    BF16 => Value::BF16,
973                    F128 => Value::F128Array,
974                    Boolean => Value::BoolArray(
975                        out.len(),
976                        out.chunks(8)
977                            .map(|v| {
978                                let mut out = 0;
979                                for v in v.iter().rev() {
980                                    out <<= 1;
981                                    if let Value::True = *v {
982                                        out |= 1
983                                    };
984                                }
985                                out
986                            })
987                            .collect(),
988                    ),
989                    Generic => Value::GenericArray(out),
990                    Complex => unreachable!(),
991                })
992            }
993
994            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
995            where
996                A: serde::de::MapAccess<'de>,
997            {
998                let Some(first) = map.next_entry::<Value, Value>()? else {
999                    return Ok(Value::StringObject(vec![]));
1000                };
1001
1002                let kind = ObjectKind::try_from(&first.0).map_err(serde::de::Error::custom)?;
1003                let mut out = vec![first];
1004                while let Some(entry) = map.next_entry::<Value, Value>()? {
1005                    let found = ObjectKind::try_from(&entry.0).map_err(serde::de::Error::custom)?;
1006                    if found != kind {
1007                        return Err(serde::de::Error::custom(crate::Error::MismatchedKeyType {
1008                            expected: kind,
1009                            found,
1010                        }));
1011                    }
1012
1013                    out.push(entry);
1014                }
1015
1016                macro_rules! convert_object {
1017                    ( $( $(#[$meta:meta])* $kind:ident => $object:ident ),* $(,)? ) => {
1018                        match kind {
1019                            $(
1020                                $(#[$meta])*
1021                                ObjectKind::$kind => Value::$object(
1022                                    out.into_iter()
1023                                        .map(|v| match v {
1024                                            (Value::$kind(k), v) => (k, v),
1025                                            _ => unreachable!(),
1026                                        })
1027                                        .collect(),
1028                                ),
1029                            )*
1030                        }
1031                    }
1032                }
1033
1034                Ok(convert_object! {
1035                    I8 => I8Object,
1036                    I16 => I16Object,
1037                    I32 => I32Object,
1038                    I64 => I64Object,
1039                    I128 => I128Object,
1040                    U8 => U8Object,
1041                    U16 => U16Object,
1042                    U32 => U32Object,
1043                    U64 => U64Object,
1044                    U128 => U128Object,
1045                    String => StringObject,
1046                })
1047            }
1048
1049            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1050            where
1051                A: serde::de::EnumAccess<'de>,
1052            {
1053                let (variant, value) = data.variant::<usize>()?;
1054                Ok(Value::Tag(
1055                    variant,
1056                    Box::new(value.newtype_variant::<Value>()?),
1057                ))
1058            }
1059        }
1060
1061        deserializer.deserialize_any(ValueVisitor)
1062    }
1063}
serde_beve/value.rs

serde_beve/
value.rs
