epee_encoding/
value.rs

1/// This module contains a `sealed` [`EpeeValue`] trait and different impls for
2/// the different possible base epee values.
3use alloc::string::String;
4use alloc::vec::Vec;
5use core::fmt::Debug;
6
7use sealed::sealed;
8
9use crate::io::*;
10use crate::varint::*;
11use crate::{EpeeObject, Error, InnerMarker, Marker, Result, MAX_STRING_LEN_POSSIBLE};
12
13/// A trait for epee values, this trait is sealed as all possible epee values are
14/// defined in the lib, to make an [`EpeeValue`] outside the lib you will need to
15/// use the trait [`EpeeObject`].
16#[sealed]
17pub trait EpeeValue: Sized {
18    const MARKER: Marker;
19
20    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self>;
21
22    fn should_write(&self) -> bool {
23        true
24    }
25
26    /// This is different than default field values and instead is the default
27    /// value of a whole type.
28    ///
29    /// For example a `Vec` has a default value of a zero length vec as when a
30    /// sequence has no entries it is not encoded.
31    fn epee_default_value() -> Option<Self> {
32        None
33    }
34
35    fn write<W: Write>(&self, w: &mut W) -> Result<()>;
36}
37
38#[sealed]
39impl<T: EpeeObject> EpeeValue for T {
40    const MARKER: Marker = Marker::new(InnerMarker::Object);
41
42    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
43        if marker != &Self::MARKER {
44            return Err(Error::Format("Marker does not match expected Marker"));
45        }
46
47        let mut skipped_objects = 0;
48        crate::read_object(r, &mut skipped_objects)
49    }
50
51    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
52        write_varint(self.number_of_fields(), w)?;
53        self.write_fields(w)
54    }
55}
56
57#[sealed]
58impl<T: EpeeObject> EpeeValue for Vec<T> {
59    const MARKER: Marker = T::MARKER.into_seq();
60
61    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
62        if !marker.is_seq {
63            return Err(Error::Format(
64                "Marker is not sequence when a sequence was expected",
65            ));
66        }
67        let len = read_varint(r)?;
68
69        let individual_marker = Marker::new(marker.inner_marker.clone());
70
71        let mut res = Vec::with_capacity(len.try_into()?);
72        for _ in 0..len {
73            res.push(T::read(r, &individual_marker)?);
74        }
75        Ok(res)
76    }
77
78    fn should_write(&self) -> bool {
79        !self.is_empty()
80    }
81
82    fn epee_default_value() -> Option<Self> {
83        Some(Vec::new())
84    }
85
86    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
87        write_varint(self.len().try_into()?, w)?;
88        for item in self.iter() {
89            item.write(w)?;
90        }
91        Ok(())
92    }
93}
94
95#[sealed]
96impl<T: EpeeObject + Debug, const N: usize> EpeeValue for [T; N] {
97    const MARKER: Marker = <T>::MARKER.into_seq();
98
99    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
100        let vec = Vec::<T>::read(r, marker)?;
101
102        if vec.len() != N {
103            return Err(Error::Format("Array has incorrect length"));
104        }
105
106        Ok(vec.try_into().unwrap())
107    }
108
109    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
110        write_varint(self.len().try_into()?, w)?;
111        for item in self.iter() {
112            item.write(w)?;
113        }
114        Ok(())
115    }
116}
117
118macro_rules! epee_numb {
119    ($numb:ty, $marker:ident) => {
120        #[sealed]
121        impl EpeeValue for $numb {
122            const MARKER: Marker = Marker::new(InnerMarker::$marker);
123
124            fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
125                if marker != &Self::MARKER {
126                    return Err(Error::Format("Marker does not match expected Marker"));
127                }
128
129                Ok(<$numb>::from_le_bytes(read_bytes(r)?))
130            }
131
132            fn write<W: Write>(&self, w: &mut W) -> Result<()> {
133                w.write_all(&self.to_le_bytes())
134            }
135        }
136    };
137}
138
139epee_numb!(i64, I64);
140epee_numb!(i32, I32);
141epee_numb!(i16, I16);
142epee_numb!(i8, I8);
143epee_numb!(u8, U8);
144epee_numb!(u16, U16);
145epee_numb!(u32, U32);
146epee_numb!(u64, U64);
147epee_numb!(f64, F64);
148
149#[sealed]
150impl EpeeValue for bool {
151    const MARKER: Marker = Marker::new(InnerMarker::Bool);
152
153    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
154        if marker != &Self::MARKER {
155            return Err(Error::Format("Marker does not match expected Marker"));
156        }
157
158        Ok(read_byte(r)? != 0)
159    }
160
161    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
162        w.write_all(&[if *self { 1 } else { 0 }])
163    }
164}
165
166#[sealed]
167impl EpeeValue for Vec<u8> {
168    const MARKER: Marker = Marker::new(InnerMarker::String);
169
170    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
171        if marker != &Self::MARKER {
172            return Err(Error::Format("Marker does not match expected Marker"));
173        }
174
175        let len = read_varint(r)?;
176        if len > MAX_STRING_LEN_POSSIBLE {
177            return Err(Error::Format("Byte array exceeded max length"));
178        }
179
180        read_var_bytes(r, len.try_into()?)
181    }
182
183    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
184        write_varint(self.len().try_into()?, w)?;
185        w.write_all(self)
186    }
187}
188
189#[sealed]
190impl EpeeValue for String {
191    const MARKER: Marker = Marker::new(InnerMarker::String);
192
193    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
194        if marker != &Self::MARKER {
195            return Err(Error::Format("Marker does not match expected Marker"));
196        }
197
198        let len = read_varint(r)?;
199        if len > MAX_STRING_LEN_POSSIBLE {
200            return Err(Error::Format("String exceeded max length"));
201        }
202
203        read_string(r, len.try_into()?)
204    }
205
206    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
207        write_varint(self.len().try_into()?, w)?;
208        w.write_all(self.as_bytes())
209    }
210}
211
212#[sealed]
213impl<const N: usize> EpeeValue for [u8; N] {
214    const MARKER: Marker = Marker::new(InnerMarker::String);
215
216    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
217        if marker != &Self::MARKER {
218            return Err(Error::Format("Marker does not match expected Marker"));
219        }
220
221        let len = read_varint(r)?;
222        if len != N.try_into()? {
223            return Err(Error::Format("Byte array has incorrect length"));
224        }
225
226        read_bytes(r)
227    }
228
229    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
230        write_varint(self.len().try_into()?, w)?;
231        w.write_all(self)
232    }
233}
234
235#[sealed]
236impl<const N: usize> EpeeValue for Vec<[u8; N]> {
237    const MARKER: Marker = <[u8; N]>::MARKER.into_seq();
238
239    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
240        if !marker.is_seq {
241            return Err(Error::Format(
242                "Marker is not sequence when a sequence was expected",
243            ));
244        }
245
246        let len = read_varint(r)?;
247
248        let individual_marker = Marker::new(marker.inner_marker.clone());
249
250        let mut res = Vec::with_capacity(len.try_into()?);
251        for _ in 0..len {
252            res.push(<[u8; N]>::read(r, &individual_marker)?);
253        }
254        Ok(res)
255    }
256
257    fn should_write(&self) -> bool {
258        !self.is_empty()
259    }
260
261    fn epee_default_value() -> Option<Self> {
262        Some(Vec::new())
263    }
264
265    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
266        write_varint(self.len().try_into()?, w)?;
267        for item in self.iter() {
268            item.write(w)?;
269        }
270        Ok(())
271    }
272}
273
274macro_rules! epee_seq {
275    ($val:ty) => {
276        #[sealed]
277        impl EpeeValue for Vec<$val> {
278            const MARKER: Marker = <$val>::MARKER.into_seq();
279
280            fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
281                if !marker.is_seq {
282                    return Err(Error::Format(
283                        "Marker is not sequence when a sequence was expected",
284                    ));
285                }
286
287                let len = read_varint(r)?;
288
289                let individual_marker = Marker::new(marker.inner_marker.clone());
290
291                let mut res = Vec::with_capacity(len.try_into()?);
292                for _ in 0..len {
293                    res.push(<$val>::read(r, &individual_marker)?);
294                }
295                Ok(res)
296            }
297
298            fn should_write(&self) -> bool {
299                !self.is_empty()
300            }
301
302            fn epee_default_value() -> Option<Self> {
303                Some(Vec::new())
304            }
305
306            fn write<W: Write>(&self, w: &mut W) -> Result<()> {
307                write_varint(self.len().try_into()?, w)?;
308                for item in self.iter() {
309                    item.write(w)?;
310                }
311                Ok(())
312            }
313        }
314
315        #[sealed]
316        impl<const N: usize> EpeeValue for [$val; N] {
317            const MARKER: Marker = <$val>::MARKER.into_seq();
318
319            fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
320                let vec = Vec::<$val>::read(r, marker)?;
321
322                if vec.len() != N {
323                    return Err(Error::Format("Array has incorrect length"));
324                }
325
326                Ok(vec.try_into().unwrap())
327            }
328
329            fn write<W: Write>(&self, w: &mut W) -> Result<()> {
330                write_varint(self.len().try_into()?, w)?;
331                for item in self.iter() {
332                    item.write(w)?;
333                }
334                Ok(())
335            }
336        }
337    };
338}
339
340epee_seq!(i64);
341epee_seq!(i32);
342epee_seq!(i16);
343epee_seq!(i8);
344epee_seq!(u64);
345epee_seq!(u32);
346epee_seq!(u16);
347epee_seq!(f64);
348epee_seq!(bool);
349epee_seq!(Vec<u8>);
350epee_seq!(String);
351
352#[sealed]
353impl<T: EpeeValue> EpeeValue for Option<T> {
354    const MARKER: Marker = T::MARKER;
355
356    fn read<R: Read>(r: &mut R, marker: &Marker) -> Result<Self> {
357        Ok(Some(T::read(r, marker)?))
358    }
359
360    fn should_write(&self) -> bool {
361        match self {
362            Some(t) => t.should_write(),
363            None => false,
364        }
365    }
366
367    fn epee_default_value() -> Option<Self> {
368        Some(None)
369    }
370
371    fn write<W: Write>(&self, w: &mut W) -> Result<()> {
372        match self {
373            Some(t) => t.write(w)?,
374            None => panic!("Can't write an Option::None value, this should be handled elsewhere"),
375        }
376        Ok(())
377    }
378}
epee_encoding/value.rs

epee_encoding/
value.rs
