1
use jetstream_wireformat::WireFormat;
2
use std::io;
3
use std::io::ErrorKind;
4
use std::io::Read;
5
use std::io::Write;
6
use std::mem;
7

            
8
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9
pub struct Frame<T: Framer> {
10
    pub tag: u16,
11
    pub msg: T,
12
}
13

            
14
impl<T: Framer + std::fmt::Debug> std::fmt::Debug for Frame<T> {
15
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16
        f.debug_struct("Frame")
17
            .field("tag", &self.tag)
18
            .field("msg", &self.msg)
19
            .finish()
20
    }
21
}
22

            
23
impl<T: Framer> From<(u16, T)> for Frame<T> {
24
348
    fn from((tag, msg): (u16, T)) -> Self {
25
348
        Self { tag, msg }
26
348
    }
27
}
28

            
29
impl<T: Framer> WireFormat for Frame<T> {
30
7690
    fn byte_size(&self) -> u32 {
31
7690
        let msg_size = self.msg.byte_size();
32
        // size + type + tag + message size
33
7690
        (mem::size_of::<u32>() + mem::size_of::<u8>() + mem::size_of::<u16>())
34
7690
            as u32
35
7690
            + msg_size
36
7690
    }
37

            
38
7674
    fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()> {
39
7674
        self.byte_size().encode(writer)?;
40

            
41
7674
        let ty = self.msg.message_type();
42

            
43
7674
        ty.encode(writer)?;
44
7674
        self.tag.encode(writer)?;
45

            
46
7674
        self.msg.encode(writer)?;
47

            
48
7674
        Ok(())
49
7674
    }
50

            
51
3240
    fn decode<R: Read>(reader: &mut R) -> io::Result<Self> {
52
3240
        let byte_size: u32 = WireFormat::decode(reader)?;
53

            
54
        // byte_size includes the size of byte_size so remove that from the
55
        // expected length of the message.  Also make sure that byte_size is at least
56
        // that long to begin with.
57
3240
        if byte_size < mem::size_of::<u32>() as u32 {
58
            return Err(io::Error::new(
59
                ErrorKind::InvalidData,
60
                format!("byte_size(= {byte_size}) is less than 4 bytes"),
61
            ));
62
3240
        }
63
        let reader =
64
3240
            &mut reader.take((byte_size - mem::size_of::<u32>() as u32) as u64);
65

            
66
3240
        let mut ty = [0u8];
67
3240
        reader.read_exact(&mut ty)?;
68

            
69
3240
        let tag: u16 = WireFormat::decode(reader)?;
70
3240
        let msg = T::decode(reader, ty[0])?;
71

            
72
3240
        Ok(Frame { tag, msg })
73
3240
    }
74
}
75

            
76
pub trait Framer: Sized + Send + Sync {
77
    fn message_type(&self) -> u8;
78
    /// Returns the number of bytes necessary to fully encode `self`.
79
    fn byte_size(&self) -> u32;
80

            
81
    /// Encodes `self` into `writer`.
82
    fn encode<W: Write>(&self, writer: &mut W) -> io::Result<()>;
83

            
84
    /// Decodes `Self` from `reader`.
85
    fn decode<R: Read>(reader: &mut R, ty: u8) -> io::Result<Self>;
86
}