nautilus_binance/spot/sbe/generated/
ticker_symbol_mini_response_codec.rs

1pub use decoder::TickerSymbolMiniResponseDecoder;
2pub use encoder::TickerSymbolMiniResponseEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 106;
8pub const SBE_TEMPLATE_ID: u16 = 215;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct TickerSymbolMiniResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for TickerSymbolMiniResponseEncoder<'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 TickerSymbolMiniResponseEncoder<'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> TickerSymbolMiniResponseEncoder<'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 'openPrice'
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 open_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 'highPrice'
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 high_price(&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 'lowPrice'
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 low_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 'lastPrice'
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 last_price(&mut self, value: i64) {
152            let offset = self.offset + 26;
153            self.get_buf_mut().put_i64_at(offset, value);
154        }
155
156        #[inline]
157        pub fn volume_at(&mut self, index: usize, value: u8) {
158            let offset = self.offset + 34;
159            let buf = self.get_buf_mut();
160            buf.put_u8_at(offset + index, value);
161        }
162
163        /// primitive array field 'volume'
164        /// - min value: 0
165        /// - max value: 254
166        /// - null value: 0xff_u8
167        /// - characterEncoding: null
168        /// - semanticType: null
169        /// - encodedOffset: 34
170        /// - encodedLength: 16
171        /// - version: 0
172        #[inline]
173        pub fn volume(&mut self, value: &[u8]) {
174            debug_assert_eq!(16, value.len());
175            let offset = self.offset + 34;
176            let buf = self.get_buf_mut();
177            buf.put_slice_at(offset, value);
178        }
179
180        /// primitive array field 'volume' from an Iterator
181        /// - min value: 0
182        /// - max value: 254
183        /// - null value: 0xff_u8
184        /// - characterEncoding: null
185        /// - semanticType: null
186        /// - encodedOffset: 34
187        /// - encodedLength: 16
188        /// - version: 0
189        #[inline]
190        pub fn volume_from_iter(&mut self, iter: impl Iterator<Item = u8>) {
191            let offset = self.offset + 34;
192            let buf = self.get_buf_mut();
193            for (i, v) in iter.enumerate() {
194                buf.put_u8_at(offset + i, v);
195            }
196        }
197
198        /// primitive array field 'volume' with zero padding
199        /// - min value: 0
200        /// - max value: 254
201        /// - null value: 0xff_u8
202        /// - characterEncoding: null
203        /// - semanticType: null
204        /// - encodedOffset: 34
205        /// - encodedLength: 16
206        /// - version: 0
207        #[inline]
208        pub fn volume_zero_padded(&mut self, value: &[u8]) {
209            let iter = value
210                .iter()
211                .copied()
212                .chain(std::iter::repeat(0_u8))
213                .take(16);
214            self.volume_from_iter(iter);
215        }
216
217        #[inline]
218        pub fn quote_volume_at(&mut self, index: usize, value: u8) {
219            let offset = self.offset + 50;
220            let buf = self.get_buf_mut();
221            buf.put_u8_at(offset + index, value);
222        }
223
224        /// primitive array field 'quoteVolume'
225        /// - min value: 0
226        /// - max value: 254
227        /// - null value: 0xff_u8
228        /// - characterEncoding: null
229        /// - semanticType: null
230        /// - encodedOffset: 50
231        /// - encodedLength: 16
232        /// - version: 0
233        #[inline]
234        pub fn quote_volume(&mut self, value: &[u8]) {
235            debug_assert_eq!(16, value.len());
236            let offset = self.offset + 50;
237            let buf = self.get_buf_mut();
238            buf.put_slice_at(offset, value);
239        }
240
241        /// primitive array field 'quoteVolume' from an Iterator
242        /// - min value: 0
243        /// - max value: 254
244        /// - null value: 0xff_u8
245        /// - characterEncoding: null
246        /// - semanticType: null
247        /// - encodedOffset: 50
248        /// - encodedLength: 16
249        /// - version: 0
250        #[inline]
251        pub fn quote_volume_from_iter(&mut self, iter: impl Iterator<Item = u8>) {
252            let offset = self.offset + 50;
253            let buf = self.get_buf_mut();
254            for (i, v) in iter.enumerate() {
255                buf.put_u8_at(offset + i, v);
256            }
257        }
258
259        /// primitive array field 'quoteVolume' with zero padding
260        /// - min value: 0
261        /// - max value: 254
262        /// - null value: 0xff_u8
263        /// - characterEncoding: null
264        /// - semanticType: null
265        /// - encodedOffset: 50
266        /// - encodedLength: 16
267        /// - version: 0
268        #[inline]
269        pub fn quote_volume_zero_padded(&mut self, value: &[u8]) {
270            let iter = value
271                .iter()
272                .copied()
273                .chain(std::iter::repeat(0_u8))
274                .take(16);
275            self.quote_volume_from_iter(iter);
276        }
277
278        /// primitive field 'openTime'
279        /// - min value: -9223372036854775807
280        /// - max value: 9223372036854775807
281        /// - null value: -9223372036854775808_i64
282        /// - characterEncoding: null
283        /// - semanticType: null
284        /// - encodedOffset: 66
285        /// - encodedLength: 8
286        /// - version: 0
287        #[inline]
288        pub fn open_time(&mut self, value: i64) {
289            let offset = self.offset + 66;
290            self.get_buf_mut().put_i64_at(offset, value);
291        }
292
293        /// primitive field 'closeTime'
294        /// - min value: -9223372036854775807
295        /// - max value: 9223372036854775807
296        /// - null value: -9223372036854775808_i64
297        /// - characterEncoding: null
298        /// - semanticType: null
299        /// - encodedOffset: 74
300        /// - encodedLength: 8
301        /// - version: 0
302        #[inline]
303        pub fn close_time(&mut self, value: i64) {
304            let offset = self.offset + 74;
305            self.get_buf_mut().put_i64_at(offset, value);
306        }
307
308        /// primitive field 'firstId'
309        /// - min value: -9223372036854775807
310        /// - max value: 9223372036854775807
311        /// - null value: -9223372036854775808_i64
312        /// - characterEncoding: null
313        /// - semanticType: null
314        /// - encodedOffset: 82
315        /// - encodedLength: 8
316        /// - version: 0
317        #[inline]
318        pub fn first_id(&mut self, value: i64) {
319            let offset = self.offset + 82;
320            self.get_buf_mut().put_i64_at(offset, value);
321        }
322
323        /// primitive field 'lastId'
324        /// - min value: -9223372036854775807
325        /// - max value: 9223372036854775807
326        /// - null value: -9223372036854775808_i64
327        /// - characterEncoding: null
328        /// - semanticType: null
329        /// - encodedOffset: 90
330        /// - encodedLength: 8
331        /// - version: 0
332        #[inline]
333        pub fn last_id(&mut self, value: i64) {
334            let offset = self.offset + 90;
335            self.get_buf_mut().put_i64_at(offset, value);
336        }
337
338        /// primitive field 'numTrades'
339        /// - min value: -9223372036854775807
340        /// - max value: 9223372036854775807
341        /// - null value: -9223372036854775808_i64
342        /// - characterEncoding: null
343        /// - semanticType: null
344        /// - encodedOffset: 98
345        /// - encodedLength: 8
346        /// - version: 0
347        #[inline]
348        pub fn num_trades(&mut self, value: i64) {
349            let offset = self.offset + 98;
350            self.get_buf_mut().put_i64_at(offset, value);
351        }
352
353        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
354        #[inline]
355        pub fn symbol(&mut self, value: &str) {
356            let limit = self.get_limit();
357            let data_length = value.len();
358            self.set_limit(limit + 1 + data_length);
359            self.get_buf_mut().put_u8_at(limit, data_length as u8);
360            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
361        }
362    }
363} // end encoder
364
365pub mod decoder {
366    use message_header_codec::*;
367
368    use super::*;
369
370    #[derive(Clone, Copy, Debug, Default)]
371    pub struct TickerSymbolMiniResponseDecoder<'a> {
372        buf: ReadBuf<'a>,
373        initial_offset: usize,
374        offset: usize,
375        limit: usize,
376        pub acting_block_length: u16,
377        pub acting_version: u16,
378    }
379
380    impl ActingVersion for TickerSymbolMiniResponseDecoder<'_> {
381        #[inline]
382        fn acting_version(&self) -> u16 {
383            self.acting_version
384        }
385    }
386
387    impl<'a> Reader<'a> for TickerSymbolMiniResponseDecoder<'a> {
388        #[inline]
389        fn get_buf(&self) -> &ReadBuf<'a> {
390            &self.buf
391        }
392    }
393
394    impl<'a> Decoder<'a> for TickerSymbolMiniResponseDecoder<'a> {
395        #[inline]
396        fn get_limit(&self) -> usize {
397            self.limit
398        }
399
400        #[inline]
401        fn set_limit(&mut self, limit: usize) {
402            self.limit = limit;
403        }
404    }
405
406    impl<'a> TickerSymbolMiniResponseDecoder<'a> {
407        pub fn wrap(
408            mut self,
409            buf: ReadBuf<'a>,
410            offset: usize,
411            acting_block_length: u16,
412            acting_version: u16,
413        ) -> Self {
414            let limit = offset + acting_block_length as usize;
415            self.buf = buf;
416            self.initial_offset = offset;
417            self.offset = offset;
418            self.limit = limit;
419            self.acting_block_length = acting_block_length;
420            self.acting_version = acting_version;
421            self
422        }
423
424        #[inline]
425        pub fn encoded_length(&self) -> usize {
426            self.limit - self.offset
427        }
428
429        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
430            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
431            let acting_block_length = header.block_length();
432            let acting_version = header.version();
433
434            self.wrap(
435                header.parent().unwrap(),
436                offset + message_header_codec::ENCODED_LENGTH,
437                acting_block_length,
438                acting_version,
439            )
440        }
441
442        /// primitive field - 'REQUIRED'
443        #[inline]
444        pub fn price_exponent(&self) -> i8 {
445            self.get_buf().get_i8_at(self.offset)
446        }
447
448        /// primitive field - 'REQUIRED'
449        #[inline]
450        pub fn qty_exponent(&self) -> i8 {
451            self.get_buf().get_i8_at(self.offset + 1)
452        }
453
454        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
455        #[inline]
456        pub fn open_price(&self) -> Option<i64> {
457            let value = self.get_buf().get_i64_at(self.offset + 2);
458            if value == -9223372036854775808_i64 {
459                None
460            } else {
461                Some(value)
462            }
463        }
464
465        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
466        #[inline]
467        pub fn high_price(&self) -> Option<i64> {
468            let value = self.get_buf().get_i64_at(self.offset + 10);
469            if value == -9223372036854775808_i64 {
470                None
471            } else {
472                Some(value)
473            }
474        }
475
476        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
477        #[inline]
478        pub fn low_price(&self) -> Option<i64> {
479            let value = self.get_buf().get_i64_at(self.offset + 18);
480            if value == -9223372036854775808_i64 {
481                None
482            } else {
483                Some(value)
484            }
485        }
486
487        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
488        #[inline]
489        pub fn last_price(&self) -> Option<i64> {
490            let value = self.get_buf().get_i64_at(self.offset + 26);
491            if value == -9223372036854775808_i64 {
492                None
493            } else {
494                Some(value)
495            }
496        }
497
498        #[inline]
499        pub fn volume(&self) -> [u8; 16] {
500            let buf = self.get_buf();
501            ReadBuf::get_bytes_at(buf.data, self.offset + 34)
502        }
503
504        #[inline]
505        pub fn quote_volume(&self) -> [u8; 16] {
506            let buf = self.get_buf();
507            ReadBuf::get_bytes_at(buf.data, self.offset + 50)
508        }
509
510        /// primitive field - 'REQUIRED'
511        #[inline]
512        pub fn open_time(&self) -> i64 {
513            self.get_buf().get_i64_at(self.offset + 66)
514        }
515
516        /// primitive field - 'REQUIRED'
517        #[inline]
518        pub fn close_time(&self) -> i64 {
519            self.get_buf().get_i64_at(self.offset + 74)
520        }
521
522        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
523        #[inline]
524        pub fn first_id(&self) -> Option<i64> {
525            let value = self.get_buf().get_i64_at(self.offset + 82);
526            if value == -9223372036854775808_i64 {
527                None
528            } else {
529                Some(value)
530            }
531        }
532
533        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
534        #[inline]
535        pub fn last_id(&self) -> Option<i64> {
536            let value = self.get_buf().get_i64_at(self.offset + 90);
537            if value == -9223372036854775808_i64 {
538                None
539            } else {
540                Some(value)
541            }
542        }
543
544        /// primitive field - 'REQUIRED'
545        #[inline]
546        pub fn num_trades(&self) -> i64 {
547            self.get_buf().get_i64_at(self.offset + 98)
548        }
549
550        /// VAR_DATA DECODER - character encoding: 'UTF-8'
551        #[inline]
552        pub fn symbol_decoder(&mut self) -> (usize, usize) {
553            let offset = self.get_limit();
554            let data_length = self.get_buf().get_u8_at(offset) as usize;
555            self.set_limit(offset + 1 + data_length);
556            (offset + 1, data_length)
557        }
558
559        #[inline]
560        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
561            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
562            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
563        }
564    }
565} // end decoder
nautilus_binance/spot/sbe/generated/ticker_symbol_mini_response_codec.rs

nautilus_binance/spot/sbe/generated/
ticker_symbol_mini_response_codec.rs
