nautilus_binance/common/sbe/spot/
ping_response_codec.rs

1pub use decoder::PingResponseDecoder;
2pub use encoder::PingResponseEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 0;
8pub const SBE_TEMPLATE_ID: u16 = 101;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct PingResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for PingResponseEncoder<'a> {
24        #[inline]
25        fn get_buf_mut(&mut self) -> &mut WriteBuf<'a> {
26            &mut self.buf
27        }
28    }
29
30    impl<'a> Encoder<'a> for PingResponseEncoder<'a> {
31        #[inline]
32        fn get_limit(&self) -> usize {
33            self.limit
34        }
35
36        #[inline]
37        fn set_limit(&mut self, limit: usize) {
38            self.limit = limit;
39        }
40    }
41
42    impl<'a> PingResponseEncoder<'a> {
43        pub fn wrap(mut self, buf: WriteBuf<'a>, offset: usize) -> Self {
44            let limit = offset + SBE_BLOCK_LENGTH as usize;
45            self.buf = buf;
46            self.initial_offset = offset;
47            self.offset = offset;
48            self.limit = limit;
49            self
50        }
51
52        #[inline]
53        pub fn encoded_length(&self) -> usize {
54            self.limit - self.offset
55        }
56
57        pub fn header(self, offset: usize) -> MessageHeaderEncoder<Self> {
58            let mut header = MessageHeaderEncoder::default().wrap(self, offset);
59            header.block_length(SBE_BLOCK_LENGTH);
60            header.template_id(SBE_TEMPLATE_ID);
61            header.schema_id(SBE_SCHEMA_ID);
62            header.version(SBE_SCHEMA_VERSION);
63            header
64        }
65    }
66} // end encoder
67
68pub mod decoder {
69    use message_header_codec::*;
70
71    use super::*;
72
73    #[derive(Clone, Copy, Debug, Default)]
74    pub struct PingResponseDecoder<'a> {
75        buf: ReadBuf<'a>,
76        initial_offset: usize,
77        offset: usize,
78        limit: usize,
79        pub acting_block_length: u16,
80        pub acting_version: u16,
81    }
82
83    impl ActingVersion for PingResponseDecoder<'_> {
84        #[inline]
85        fn acting_version(&self) -> u16 {
86            self.acting_version
87        }
88    }
89
90    impl<'a> Reader<'a> for PingResponseDecoder<'a> {
91        #[inline]
92        fn get_buf(&self) -> &ReadBuf<'a> {
93            &self.buf
94        }
95    }
96
97    impl<'a> Decoder<'a> for PingResponseDecoder<'a> {
98        #[inline]
99        fn get_limit(&self) -> usize {
100            self.limit
101        }
102
103        #[inline]
104        fn set_limit(&mut self, limit: usize) {
105            self.limit = limit;
106        }
107    }
108
109    impl<'a> PingResponseDecoder<'a> {
110        pub fn wrap(
111            mut self,
112            buf: ReadBuf<'a>,
113            offset: usize,
114            acting_block_length: u16,
115            acting_version: u16,
116        ) -> Self {
117            let limit = offset + acting_block_length as usize;
118            self.buf = buf;
119            self.initial_offset = offset;
120            self.offset = offset;
121            self.limit = limit;
122            self.acting_block_length = acting_block_length;
123            self.acting_version = acting_version;
124            self
125        }
126
127        #[inline]
128        pub fn encoded_length(&self) -> usize {
129            self.limit - self.offset
130        }
131
132        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
133            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
134            let acting_block_length = header.block_length();
135            let acting_version = header.version();
136
137            self.wrap(
138                header.parent().unwrap(),
139                offset + message_header_codec::ENCODED_LENGTH,
140                acting_block_length,
141                acting_version,
142            )
143        }
144    }
145} // end decoder
nautilus_binance/common/sbe/spot/ping_response_codec.rs

nautilus_binance/common/sbe/spot/
ping_response_codec.rs
