Skip to main content

sk_app/embed/
bytes.rs

1//! Binary data for native modules: a `Uint8Array` in JS. `#[serde(with = "skathi::bytes")]` puts
2//! a `Vec<u8>` field in that form; `#[skathi::data]` does it for every `Vec<u8>` field.
3
4use std::fmt;
5use std::ops::{Deref, DerefMut};
6
7use serde::de::{self, Deserializer, SeqAccess, Visitor};
8use serde::ser::Serializer;
9use serde::{Deserialize, Serialize};
10
11/// Bytes that reach JS as a `Uint8Array`, read from any `ArrayBufferView`, an `ArrayBuffer` or
12/// an array of numbers.
13#[derive(Clone, Default, PartialEq, Eq, Hash, PartialOrd, Ord)]
14pub struct Bytes(pub Vec<u8>);
15
16impl fmt::Debug for Bytes {
17    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
18        self.0.fmt(f)
19    }
20}
21
22impl Deref for Bytes {
23    type Target = Vec<u8>;
24    fn deref(&self) -> &Vec<u8> {
25        &self.0
26    }
27}
28
29impl DerefMut for Bytes {
30    fn deref_mut(&mut self) -> &mut Vec<u8> {
31        &mut self.0
32    }
33}
34
35impl From<Vec<u8>> for Bytes {
36    fn from(v: Vec<u8>) -> Self {
37        Self(v)
38    }
39}
40
41impl From<&[u8]> for Bytes {
42    fn from(v: &[u8]) -> Self {
43        Self(v.to_vec())
44    }
45}
46
47impl From<Bytes> for Vec<u8> {
48    fn from(v: Bytes) -> Self {
49        v.0
50    }
51}
52
53impl AsRef<[u8]> for Bytes {
54    fn as_ref(&self) -> &[u8] {
55        &self.0
56    }
57}
58
59impl Serialize for Bytes {
60    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
61        serializer.serialize_bytes(&self.0)
62    }
63}
64
65impl<'de> Deserialize<'de> for Bytes {
66    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
67        deserializer.deserialize_byte_buf(BytesVisitor).map(Bytes)
68    }
69}
70
71struct BytesVisitor;
72
73impl<'de> Visitor<'de> for BytesVisitor {
74    type Value = Vec<u8>;
75
76    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
77        f.write_str("a Uint8Array, an ArrayBuffer or an array of bytes")
78    }
79
80    fn visit_bytes<E: de::Error>(self, v: &[u8]) -> Result<Vec<u8>, E> {
81        Ok(v.to_vec())
82    }
83
84    fn visit_byte_buf<E: de::Error>(self, v: Vec<u8>) -> Result<Vec<u8>, E> {
85        Ok(v)
86    }
87
88    fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Vec<u8>, A::Error> {
89        let mut out = Vec::with_capacity(seq.size_hint().unwrap_or(0).min(1 << 20));
90        while let Some(b) = seq.next_element::<u8>()? {
91            out.push(b);
92        }
93        Ok(out)
94    }
95}
96
97#[cfg(feature = "types")]
98impl specta::Type for Bytes {
99    fn definition(_: &mut specta::Types) -> specta::datatype::DataType {
100        specta_typescript::define("Uint8Array").into()
101    }
102}
103
104/// `#[serde(with = "skathi::bytes")]` for a `Vec<u8>`.
105pub fn serialize<S: Serializer>(v: &[u8], serializer: S) -> Result<S::Ok, S::Error> {
106    serializer.serialize_bytes(v)
107}
108
109/// `#[serde(with = "skathi::bytes")]` for a `Vec<u8>`.
110pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<u8>, D::Error> {
111    deserializer.deserialize_byte_buf(BytesVisitor)
112}
113
114/// `#[serde(with = "skathi::bytes::option", default)]` for an `Option<Vec<u8>>`.
115pub mod option {
116    use super::*;
117
118    struct Slice<'a>(&'a [u8]);
119
120    impl Serialize for Slice<'_> {
121        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
122            serializer.serialize_bytes(self.0)
123        }
124    }
125
126    pub fn serialize<S: Serializer>(v: &Option<Vec<u8>>, serializer: S) -> Result<S::Ok, S::Error> {
127        match v {
128            Some(v) => serializer.serialize_some(&Slice(v)),
129            None => serializer.serialize_none(),
130        }
131    }
132
133    pub fn deserialize<'de, D: Deserializer<'de>>(
134        deserializer: D,
135    ) -> Result<Option<Vec<u8>>, D::Error> {
136        Ok(Option::<Bytes>::deserialize(deserializer)?.map(|b| b.0))
137    }
138}