1use 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#[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
104pub fn serialize<S: Serializer>(v: &[u8], serializer: S) -> Result<S::Ok, S::Error> {
106 serializer.serialize_bytes(v)
107}
108
109pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<u8>, D::Error> {
111 deserializer.deserialize_byte_buf(BytesVisitor)
112}
113
114pub 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}