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}