vortex_array/
metadata.rs

1use std::fmt::{Debug, Formatter};
2
3use vortex_error::{VortexExpect, VortexResult, vortex_bail, vortex_err};
4
5pub trait SerializeMetadata {
6    fn serialize(&self) -> Option<Vec<u8>>;
7}
8
9impl SerializeMetadata for () {
10    fn serialize(&self) -> Option<Vec<u8>> {
11        None
12    }
13}
14
15pub trait DeserializeMetadata
16where
17    Self: Sized,
18{
19    type Output;
20
21    fn deserialize(metadata: Option<&[u8]>) -> VortexResult<Self::Output>;
22
23    /// Deserialize metadata without validation.
24    ///
25    /// ## Safety
26    ///
27    /// Those who use this API must be sure to have invoked deserialize at least once before
28    /// calling this method.
29    unsafe fn deserialize_unchecked(metadata: Option<&[u8]>) -> Self::Output {
30        Self::deserialize(metadata)
31            .vortex_expect("Metadata should have been validated before calling this method")
32    }
33
34    /// Format metadata for display.
35    fn format(metadata: Option<&[u8]>, f: &mut Formatter<'_>) -> std::fmt::Result;
36}
37
38/// Empty array metadata
39#[derive(Debug)]
40pub struct EmptyMetadata;
41
42impl SerializeMetadata for EmptyMetadata {
43    fn serialize(&self) -> Option<Vec<u8>> {
44        None
45    }
46}
47
48impl DeserializeMetadata for EmptyMetadata {
49    type Output = EmptyMetadata;
50
51    fn deserialize(metadata: Option<&[u8]>) -> VortexResult<Self::Output> {
52        if metadata.is_some() {
53            vortex_bail!("EmptyMetadata should not have metadata bytes")
54        }
55        Ok(EmptyMetadata)
56    }
57
58    fn format(_metadata: Option<&[u8]>, f: &mut Formatter<'_>) -> std::fmt::Result {
59        f.write_str("EmptyMetadata")
60    }
61}
62
63/// A utility wrapper for Prost metadata serialization.
64pub struct ProstMetadata<M>(pub M);
65
66impl<M: Debug> Debug for ProstMetadata<M> {
67    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
68        self.0.fmt(f)
69    }
70}
71
72impl<M> SerializeMetadata for ProstMetadata<M>
73where
74    M: prost::Message,
75{
76    fn serialize(&self) -> Option<Vec<u8>> {
77        Some(self.0.encode_to_vec())
78    }
79}
80
81impl<M> DeserializeMetadata for ProstMetadata<M>
82where
83    M: Debug,
84    M: prost::Message + Default,
85{
86    type Output = M;
87
88    fn deserialize(metadata: Option<&[u8]>) -> VortexResult<Self::Output> {
89        let bytes =
90            metadata.ok_or_else(|| vortex_err!("Prost metadata requires metadata bytes"))?;
91        Ok(M::decode(bytes)?)
92    }
93
94    #[allow(clippy::use_debug)]
95    fn format(metadata: Option<&[u8]>, f: &mut Formatter<'_>) -> std::fmt::Result {
96        match Self::deserialize(metadata) {
97            Ok(m) => write!(f, "{:?}", m),
98            Err(_) => write!(f, "Failed to deserialize metadata"),
99        }
100    }
101}