rsiot/serde_utils/
postcard_serde.rs1#![deprecated]
4
5use std::fmt::Debug;
6
7use crc::{Crc, Digest, Table, CRC_32_ISCSI};
8use postcard::{from_bytes, from_bytes_crc32, to_slice_crc32, to_stdvec, to_stdvec_crc32};
9use serde::{de::DeserializeOwned, Serialize};
10
11pub const MESSAGE_LEN: usize = 32;
13
14const CRC_DIGEST: Digest<u32, Table<1>> = Crc::<u32>::new(&CRC_32_ISCSI).digest();
15
16pub fn serialize_nocrc<T>(data: &T) -> Result<Vec<u8>, Error>
18where
19 T: Serialize,
20{
21 let buffer = to_stdvec(data).map_err(Error::SerializationError)?;
22 Ok(buffer)
23}
24
25pub fn serialize_crc<T>(data: &T) -> Result<Vec<u8>, Error>
27where
28 T: Serialize,
29{
30 let buffer = to_stdvec_crc32(data, CRC_DIGEST).map_err(Error::SerializationError)?;
31
32 Ok(buffer)
33}
34
35pub fn deserialize_crc<T>(buffer: &mut [u8]) -> Result<T, Error>
37where
38 T: DeserializeOwned,
39{
40 from_bytes_crc32(buffer, CRC_DIGEST).map_err(|e| Error::DeserializationError {
41 error: e,
42 buffer: buffer.to_vec(),
43 })
44}
45
46pub fn deserialize_nocrc<T>(buffer: &mut [u8]) -> Result<T, Error>
48where
49 T: DeserializeOwned,
50{
51 from_bytes(buffer).map_err(|e| Error::DeserializationError {
52 error: e,
53 buffer: buffer.to_vec(),
54 })
55}
56
57#[deprecated]
59pub fn serialize_nocrc_deprecated<T>(data: &T) -> Result<Vec<u8>, Error>
60where
61 T: Debug + Serialize,
62{
63 let mut buffer = to_stdvec(data).map_err(Error::SerializationError)?;
64
65 if buffer.len() > MESSAGE_LEN {
66 return Err(Error::BufferTooLarge {
67 buffer_len: buffer.len(),
68 });
69 }
70 buffer.resize(MESSAGE_LEN, 0xFF);
71
72 Ok(buffer)
73}
74
75#[deprecated]
77pub fn serialize_crc_deprecated<T>(data: &T) -> Result<Vec<u8>, Error>
78where
79 T: Debug + Serialize,
80{
81 let mut buffer = to_stdvec_crc32(data, CRC_DIGEST).map_err(Error::SerializationError)?;
82
83 if buffer.len() > MESSAGE_LEN {
84 return Err(Error::BufferTooLarge {
85 buffer_len: buffer.len(),
86 });
87 }
88 buffer.resize(MESSAGE_LEN, 0xFF);
89
90 Ok(buffer)
91}
92
93#[deprecated]
95pub fn serialize<T, const MESSAGE_LEN: usize>(data: &T) -> Result<[u8; MESSAGE_LEN], Error>
96where
97 T: Debug + Serialize,
98{
99 let mut buffer = [0xFF; MESSAGE_LEN];
100 let _ = to_slice_crc32(data, &mut buffer, CRC_DIGEST).map_err(Error::SerializationError)?;
101
102 if buffer.len() > MESSAGE_LEN {
103 return Err(Error::BufferTooLarge {
104 buffer_len: buffer.len(),
105 });
106 }
107
108 Ok(buffer)
109}
110
111#[deprecated]
113pub fn deserialize<T>(buffer: &mut [u8]) -> Result<T, Error>
114where
115 T: Debug + DeserializeOwned,
116{
117 deserialize_crc(buffer)
118}
119
120#[allow(missing_docs)]
121#[derive(Debug, thiserror::Error)]
122pub enum Error {
123 #[error(transparent)]
124 SerializationError(postcard::Error),
125
126 #[error("Buffer too large. Buffer len: {buffer_len}, message len: {MESSAGE_LEN}. Increase MESSAGE_LEN constant.")]
127 BufferTooLarge { buffer_len: usize },
128
129 #[error("Deserialization error: {error}. Buffer: {buffer:x?}")]
130 DeserializationError {
131 error: postcard::Error,
132 buffer: Vec<u8>,
133 },
134}