nautilus_binance/spot/sbe/generated/
book_ticker_symbol_response_codec.rs

1pub use decoder::BookTickerSymbolResponseDecoder;
2pub use encoder::BookTickerSymbolResponseEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 34;
8pub const SBE_TEMPLATE_ID: u16 = 211;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct BookTickerSymbolResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for BookTickerSymbolResponseEncoder<'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 BookTickerSymbolResponseEncoder<'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> BookTickerSymbolResponseEncoder<'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        /// primitive field 'priceExponent'
67        /// - min value: -127
68        /// - max value: 127
69        /// - null value: -128_i8
70        /// - characterEncoding: null
71        /// - semanticType: null
72        /// - encodedOffset: 0
73        /// - encodedLength: 1
74        /// - version: 0
75        #[inline]
76        pub fn price_exponent(&mut self, value: i8) {
77            let offset = self.offset;
78            self.get_buf_mut().put_i8_at(offset, value);
79        }
80
81        /// primitive field 'qtyExponent'
82        /// - min value: -127
83        /// - max value: 127
84        /// - null value: -128_i8
85        /// - characterEncoding: null
86        /// - semanticType: null
87        /// - encodedOffset: 1
88        /// - encodedLength: 1
89        /// - version: 0
90        #[inline]
91        pub fn qty_exponent(&mut self, value: i8) {
92            let offset = self.offset + 1;
93            self.get_buf_mut().put_i8_at(offset, value);
94        }
95
96        /// primitive field 'bidPrice'
97        /// - min value: -9223372036854775807
98        /// - max value: 9223372036854775807
99        /// - null value: -9223372036854775808_i64
100        /// - characterEncoding: null
101        /// - semanticType: null
102        /// - encodedOffset: 2
103        /// - encodedLength: 8
104        /// - version: 0
105        #[inline]
106        pub fn bid_price(&mut self, value: i64) {
107            let offset = self.offset + 2;
108            self.get_buf_mut().put_i64_at(offset, value);
109        }
110
111        /// primitive field 'bidQty'
112        /// - min value: -9223372036854775807
113        /// - max value: 9223372036854775807
114        /// - null value: -9223372036854775808_i64
115        /// - characterEncoding: null
116        /// - semanticType: null
117        /// - encodedOffset: 10
118        /// - encodedLength: 8
119        /// - version: 0
120        #[inline]
121        pub fn bid_qty(&mut self, value: i64) {
122            let offset = self.offset + 10;
123            self.get_buf_mut().put_i64_at(offset, value);
124        }
125
126        /// primitive field 'askPrice'
127        /// - min value: -9223372036854775807
128        /// - max value: 9223372036854775807
129        /// - null value: -9223372036854775808_i64
130        /// - characterEncoding: null
131        /// - semanticType: null
132        /// - encodedOffset: 18
133        /// - encodedLength: 8
134        /// - version: 0
135        #[inline]
136        pub fn ask_price(&mut self, value: i64) {
137            let offset = self.offset + 18;
138            self.get_buf_mut().put_i64_at(offset, value);
139        }
140
141        /// primitive field 'askQty'
142        /// - min value: -9223372036854775807
143        /// - max value: 9223372036854775807
144        /// - null value: -9223372036854775808_i64
145        /// - characterEncoding: null
146        /// - semanticType: null
147        /// - encodedOffset: 26
148        /// - encodedLength: 8
149        /// - version: 0
150        #[inline]
151        pub fn ask_qty(&mut self, value: i64) {
152            let offset = self.offset + 26;
153            self.get_buf_mut().put_i64_at(offset, value);
154        }
155
156        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
157        #[inline]
158        pub fn symbol(&mut self, value: &str) {
159            let limit = self.get_limit();
160            let data_length = value.len();
161            self.set_limit(limit + 1 + data_length);
162            self.get_buf_mut().put_u8_at(limit, data_length as u8);
163            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
164        }
165    }
166} // end encoder
167
168pub mod decoder {
169    use message_header_codec::*;
170
171    use super::*;
172
173    #[derive(Clone, Copy, Debug, Default)]
174    pub struct BookTickerSymbolResponseDecoder<'a> {
175        buf: ReadBuf<'a>,
176        initial_offset: usize,
177        offset: usize,
178        limit: usize,
179        pub acting_block_length: u16,
180        pub acting_version: u16,
181    }
182
183    impl ActingVersion for BookTickerSymbolResponseDecoder<'_> {
184        #[inline]
185        fn acting_version(&self) -> u16 {
186            self.acting_version
187        }
188    }
189
190    impl<'a> Reader<'a> for BookTickerSymbolResponseDecoder<'a> {
191        #[inline]
192        fn get_buf(&self) -> &ReadBuf<'a> {
193            &self.buf
194        }
195    }
196
197    impl<'a> Decoder<'a> for BookTickerSymbolResponseDecoder<'a> {
198        #[inline]
199        fn get_limit(&self) -> usize {
200            self.limit
201        }
202
203        #[inline]
204        fn set_limit(&mut self, limit: usize) {
205            self.limit = limit;
206        }
207    }
208
209    impl<'a> BookTickerSymbolResponseDecoder<'a> {
210        pub fn wrap(
211            mut self,
212            buf: ReadBuf<'a>,
213            offset: usize,
214            acting_block_length: u16,
215            acting_version: u16,
216        ) -> Self {
217            let limit = offset + acting_block_length as usize;
218            self.buf = buf;
219            self.initial_offset = offset;
220            self.offset = offset;
221            self.limit = limit;
222            self.acting_block_length = acting_block_length;
223            self.acting_version = acting_version;
224            self
225        }
226
227        #[inline]
228        pub fn encoded_length(&self) -> usize {
229            self.limit - self.offset
230        }
231
232        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
233            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
234            let acting_block_length = header.block_length();
235            let acting_version = header.version();
236
237            self.wrap(
238                header.parent().unwrap(),
239                offset + message_header_codec::ENCODED_LENGTH,
240                acting_block_length,
241                acting_version,
242            )
243        }
244
245        /// primitive field - 'REQUIRED'
246        #[inline]
247        pub fn price_exponent(&self) -> i8 {
248            self.get_buf().get_i8_at(self.offset)
249        }
250
251        /// primitive field - 'REQUIRED'
252        #[inline]
253        pub fn qty_exponent(&self) -> i8 {
254            self.get_buf().get_i8_at(self.offset + 1)
255        }
256
257        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
258        #[inline]
259        pub fn bid_price(&self) -> Option<i64> {
260            let value = self.get_buf().get_i64_at(self.offset + 2);
261            if value == -9223372036854775808_i64 {
262                None
263            } else {
264                Some(value)
265            }
266        }
267
268        /// primitive field - 'REQUIRED'
269        #[inline]
270        pub fn bid_qty(&self) -> i64 {
271            self.get_buf().get_i64_at(self.offset + 10)
272        }
273
274        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
275        #[inline]
276        pub fn ask_price(&self) -> Option<i64> {
277            let value = self.get_buf().get_i64_at(self.offset + 18);
278            if value == -9223372036854775808_i64 {
279                None
280            } else {
281                Some(value)
282            }
283        }
284
285        /// primitive field - 'REQUIRED'
286        #[inline]
287        pub fn ask_qty(&self) -> i64 {
288            self.get_buf().get_i64_at(self.offset + 26)
289        }
290
291        /// VAR_DATA DECODER - character encoding: 'UTF-8'
292        #[inline]
293        pub fn symbol_decoder(&mut self) -> (usize, usize) {
294            let offset = self.get_limit();
295            let data_length = self.get_buf().get_u8_at(offset) as usize;
296            self.set_limit(offset + 1 + data_length);
297            (offset + 1, data_length)
298        }
299
300        #[inline]
301        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
302            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
303            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
304        }
305    }
306} // end decoder
nautilus_binance/spot/sbe/generated/book_ticker_symbol_response_codec.rs

nautilus_binance/spot/sbe/generated/
book_ticker_symbol_response_codec.rs
