packet_ipc/
packet.rs

1use serde::{Deserialize, Serialize};
2
3pub trait AsIpcPacket {
4    fn timestamp(&self) -> &std::time::SystemTime;
5    fn data(&self) -> &[u8];
6}
7
8#[derive(Debug, Deserialize, Serialize)]
9pub struct IpcPacket<'a> {
10    timestamp: std::time::SystemTime,
11    #[serde(with = "serde_bytes")]
12    data: &'a [u8],
13}
14
15impl<'a, T: AsIpcPacket> From<&'a T> for IpcPacket<'a> {
16    fn from(v: &'a T) -> Self {
17        IpcPacket {
18            timestamp: v.timestamp().clone(),
19            data: v.data(),
20        }
21    }
22}
23
24impl<'a> From<IpcPacket<'a>> for Packet {
25    fn from(v: IpcPacket<'a>) -> Self {
26        Packet {
27            ts: v.timestamp.clone(),
28            data: v.data.to_vec(),
29        }
30    }
31}
32
33#[derive(Debug)]
34pub struct Packet {
35    ts: std::time::SystemTime,
36    data: Vec<u8>,
37}
38
39impl Packet {
40    pub fn new(ts: std::time::SystemTime, data: Vec<u8>) -> Packet {
41        Packet { ts, data }
42    }
43
44    pub fn into_data(self) -> Vec<u8> {
45        self.data
46    }
47}
48
49impl AsIpcPacket for Packet {
50    fn timestamp(&self) -> &std::time::SystemTime {
51        &self.ts
52    }
53    fn data(&self) -> &[u8] {
54        self.data.as_ref()
55    }
56}
57
58#[macro_export]
59macro_rules! impl_ipc_serialize(
60    (
61        $t:ident
62    ) => {
63        impl serde::Serialize for $t {
64            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
65            where
66                S: serde::Serializer,
67            {
68                let packet = IpcPacket::from(self);
69                packet.serialize(serializer)
70            }
71        }
72    }
73);
74
75impl_ipc_serialize!(Packet);
76
77impl<'de> Deserialize<'de> for Packet {
78    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
79    where
80        D: serde::Deserializer<'de>,
81    {
82        let ipc_packet = IpcPacket::deserialize(deserializer)?;
83        Ok(ipc_packet.into())
84    }
85}