nautilus_binance/spot/sbe/generated/
ticker_mini_response_codec.rs

1pub use decoder::TickerMiniResponseDecoder;
2pub use encoder::TickerMiniResponseEncoder;
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 = 216;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct TickerMiniResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for TickerMiniResponseEncoder<'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 TickerMiniResponseEncoder<'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> TickerMiniResponseEncoder<'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        /// GROUP ENCODER (id=100)
67        #[inline]
68        pub fn tickers_encoder(
69            self,
70            count: u32,
71            tickers_encoder: TickersEncoder<Self>,
72        ) -> TickersEncoder<Self> {
73            tickers_encoder.wrap(self, count)
74        }
75    }
76
77    #[derive(Debug, Default)]
78    pub struct TickersEncoder<P> {
79        parent: Option<P>,
80        count: u32,
81        index: usize,
82        offset: usize,
83        initial_limit: usize,
84    }
85
86    impl<'a, P> Writer<'a> for TickersEncoder<P>
87    where
88        P: Writer<'a> + Default,
89    {
90        #[inline]
91        fn get_buf_mut(&mut self) -> &mut WriteBuf<'a> {
92            if let Some(parent) = self.parent.as_mut() {
93                parent.get_buf_mut()
94            } else {
95                panic!("parent was None")
96            }
97        }
98    }
99
100    impl<'a, P> Encoder<'a> for TickersEncoder<P>
101    where
102        P: Encoder<'a> + Default,
103    {
104        #[inline]
105        fn get_limit(&self) -> usize {
106            self.parent.as_ref().expect("parent missing").get_limit()
107        }
108
109        #[inline]
110        fn set_limit(&mut self, limit: usize) {
111            self.parent
112                .as_mut()
113                .expect("parent missing")
114                .set_limit(limit);
115        }
116    }
117
118    impl<'a, P> TickersEncoder<P>
119    where
120        P: Encoder<'a> + Default,
121    {
122        #[inline]
123        pub fn wrap(mut self, mut parent: P, count: u32) -> Self {
124            let initial_limit = parent.get_limit();
125            parent.set_limit(initial_limit + 6);
126            parent
127                .get_buf_mut()
128                .put_u16_at(initial_limit, Self::block_length());
129            parent.get_buf_mut().put_u32_at(initial_limit + 2, count);
130            self.parent = Some(parent);
131            self.count = count;
132            self.index = usize::MAX;
133            self.offset = usize::MAX;
134            self.initial_limit = initial_limit;
135            self
136        }
137
138        #[inline]
139        pub fn block_length() -> u16 {
140            106
141        }
142
143        #[inline]
144        pub fn parent(&mut self) -> SbeResult<P> {
145            self.parent.take().ok_or(SbeErr::ParentNotSet)
146        }
147
148        /// will return Some(current index) when successful otherwise None
149        #[inline]
150        pub fn advance(&mut self) -> SbeResult<Option<usize>> {
151            let index = self.index.wrapping_add(1);
152            if index >= self.count as usize {
153                return Ok(None);
154            }
155
156            if let Some(parent) = self.parent.as_mut() {
157                self.offset = parent.get_limit();
158                parent.set_limit(self.offset + Self::block_length() as usize);
159                self.index = index;
160                Ok(Some(index))
161            } else {
162                Err(SbeErr::ParentNotSet)
163            }
164        }
165
166        /// primitive field 'priceExponent'
167        /// - min value: -127
168        /// - max value: 127
169        /// - null value: -128_i8
170        /// - characterEncoding: null
171        /// - semanticType: null
172        /// - encodedOffset: 0
173        /// - encodedLength: 1
174        /// - version: 0
175        #[inline]
176        pub fn price_exponent(&mut self, value: i8) {
177            let offset = self.offset;
178            self.get_buf_mut().put_i8_at(offset, value);
179        }
180
181        /// primitive field 'qtyExponent'
182        /// - min value: -127
183        /// - max value: 127
184        /// - null value: -128_i8
185        /// - characterEncoding: null
186        /// - semanticType: null
187        /// - encodedOffset: 1
188        /// - encodedLength: 1
189        /// - version: 0
190        #[inline]
191        pub fn qty_exponent(&mut self, value: i8) {
192            let offset = self.offset + 1;
193            self.get_buf_mut().put_i8_at(offset, value);
194        }
195
196        /// primitive field 'openPrice'
197        /// - min value: -9223372036854775807
198        /// - max value: 9223372036854775807
199        /// - null value: -9223372036854775808_i64
200        /// - characterEncoding: null
201        /// - semanticType: null
202        /// - encodedOffset: 2
203        /// - encodedLength: 8
204        /// - version: 0
205        #[inline]
206        pub fn open_price(&mut self, value: i64) {
207            let offset = self.offset + 2;
208            self.get_buf_mut().put_i64_at(offset, value);
209        }
210
211        /// primitive field 'highPrice'
212        /// - min value: -9223372036854775807
213        /// - max value: 9223372036854775807
214        /// - null value: -9223372036854775808_i64
215        /// - characterEncoding: null
216        /// - semanticType: null
217        /// - encodedOffset: 10
218        /// - encodedLength: 8
219        /// - version: 0
220        #[inline]
221        pub fn high_price(&mut self, value: i64) {
222            let offset = self.offset + 10;
223            self.get_buf_mut().put_i64_at(offset, value);
224        }
225
226        /// primitive field 'lowPrice'
227        /// - min value: -9223372036854775807
228        /// - max value: 9223372036854775807
229        /// - null value: -9223372036854775808_i64
230        /// - characterEncoding: null
231        /// - semanticType: null
232        /// - encodedOffset: 18
233        /// - encodedLength: 8
234        /// - version: 0
235        #[inline]
236        pub fn low_price(&mut self, value: i64) {
237            let offset = self.offset + 18;
238            self.get_buf_mut().put_i64_at(offset, value);
239        }
240
241        /// primitive field 'lastPrice'
242        /// - min value: -9223372036854775807
243        /// - max value: 9223372036854775807
244        /// - null value: -9223372036854775808_i64
245        /// - characterEncoding: null
246        /// - semanticType: null
247        /// - encodedOffset: 26
248        /// - encodedLength: 8
249        /// - version: 0
250        #[inline]
251        pub fn last_price(&mut self, value: i64) {
252            let offset = self.offset + 26;
253            self.get_buf_mut().put_i64_at(offset, value);
254        }
255
256        #[inline]
257        pub fn volume_at(&mut self, index: usize, value: u8) {
258            let offset = self.offset + 34;
259            let buf = self.get_buf_mut();
260            buf.put_u8_at(offset + index, value);
261        }
262
263        /// primitive array field 'volume'
264        /// - min value: 0
265        /// - max value: 254
266        /// - null value: 0xff_u8
267        /// - characterEncoding: null
268        /// - semanticType: null
269        /// - encodedOffset: 34
270        /// - encodedLength: 16
271        /// - version: 0
272        #[inline]
273        pub fn volume(&mut self, value: &[u8]) {
274            debug_assert_eq!(16, value.len());
275            let offset = self.offset + 34;
276            let buf = self.get_buf_mut();
277            buf.put_slice_at(offset, value);
278        }
279
280        /// primitive array field 'volume' from an Iterator
281        /// - min value: 0
282        /// - max value: 254
283        /// - null value: 0xff_u8
284        /// - characterEncoding: null
285        /// - semanticType: null
286        /// - encodedOffset: 34
287        /// - encodedLength: 16
288        /// - version: 0
289        #[inline]
290        pub fn volume_from_iter(&mut self, iter: impl Iterator<Item = u8>) {
291            let offset = self.offset + 34;
292            let buf = self.get_buf_mut();
293            for (i, v) in iter.enumerate() {
294                buf.put_u8_at(offset + i, v);
295            }
296        }
297
298        /// primitive array field 'volume' with zero padding
299        /// - min value: 0
300        /// - max value: 254
301        /// - null value: 0xff_u8
302        /// - characterEncoding: null
303        /// - semanticType: null
304        /// - encodedOffset: 34
305        /// - encodedLength: 16
306        /// - version: 0
307        #[inline]
308        pub fn volume_zero_padded(&mut self, value: &[u8]) {
309            let iter = value
310                .iter()
311                .copied()
312                .chain(std::iter::repeat(0_u8))
313                .take(16);
314            self.volume_from_iter(iter);
315        }
316
317        #[inline]
318        pub fn quote_volume_at(&mut self, index: usize, value: u8) {
319            let offset = self.offset + 50;
320            let buf = self.get_buf_mut();
321            buf.put_u8_at(offset + index, value);
322        }
323
324        /// primitive array field 'quoteVolume'
325        /// - min value: 0
326        /// - max value: 254
327        /// - null value: 0xff_u8
328        /// - characterEncoding: null
329        /// - semanticType: null
330        /// - encodedOffset: 50
331        /// - encodedLength: 16
332        /// - version: 0
333        #[inline]
334        pub fn quote_volume(&mut self, value: &[u8]) {
335            debug_assert_eq!(16, value.len());
336            let offset = self.offset + 50;
337            let buf = self.get_buf_mut();
338            buf.put_slice_at(offset, value);
339        }
340
341        /// primitive array field 'quoteVolume' from an Iterator
342        /// - min value: 0
343        /// - max value: 254
344        /// - null value: 0xff_u8
345        /// - characterEncoding: null
346        /// - semanticType: null
347        /// - encodedOffset: 50
348        /// - encodedLength: 16
349        /// - version: 0
350        #[inline]
351        pub fn quote_volume_from_iter(&mut self, iter: impl Iterator<Item = u8>) {
352            let offset = self.offset + 50;
353            let buf = self.get_buf_mut();
354            for (i, v) in iter.enumerate() {
355                buf.put_u8_at(offset + i, v);
356            }
357        }
358
359        /// primitive array field 'quoteVolume' with zero padding
360        /// - min value: 0
361        /// - max value: 254
362        /// - null value: 0xff_u8
363        /// - characterEncoding: null
364        /// - semanticType: null
365        /// - encodedOffset: 50
366        /// - encodedLength: 16
367        /// - version: 0
368        #[inline]
369        pub fn quote_volume_zero_padded(&mut self, value: &[u8]) {
370            let iter = value
371                .iter()
372                .copied()
373                .chain(std::iter::repeat(0_u8))
374                .take(16);
375            self.quote_volume_from_iter(iter);
376        }
377
378        /// primitive field 'openTime'
379        /// - min value: -9223372036854775807
380        /// - max value: 9223372036854775807
381        /// - null value: -9223372036854775808_i64
382        /// - characterEncoding: null
383        /// - semanticType: null
384        /// - encodedOffset: 66
385        /// - encodedLength: 8
386        /// - version: 0
387        #[inline]
388        pub fn open_time(&mut self, value: i64) {
389            let offset = self.offset + 66;
390            self.get_buf_mut().put_i64_at(offset, value);
391        }
392
393        /// primitive field 'closeTime'
394        /// - min value: -9223372036854775807
395        /// - max value: 9223372036854775807
396        /// - null value: -9223372036854775808_i64
397        /// - characterEncoding: null
398        /// - semanticType: null
399        /// - encodedOffset: 74
400        /// - encodedLength: 8
401        /// - version: 0
402        #[inline]
403        pub fn close_time(&mut self, value: i64) {
404            let offset = self.offset + 74;
405            self.get_buf_mut().put_i64_at(offset, value);
406        }
407
408        /// primitive field 'firstId'
409        /// - min value: -9223372036854775807
410        /// - max value: 9223372036854775807
411        /// - null value: -9223372036854775808_i64
412        /// - characterEncoding: null
413        /// - semanticType: null
414        /// - encodedOffset: 82
415        /// - encodedLength: 8
416        /// - version: 0
417        #[inline]
418        pub fn first_id(&mut self, value: i64) {
419            let offset = self.offset + 82;
420            self.get_buf_mut().put_i64_at(offset, value);
421        }
422
423        /// primitive field 'lastId'
424        /// - min value: -9223372036854775807
425        /// - max value: 9223372036854775807
426        /// - null value: -9223372036854775808_i64
427        /// - characterEncoding: null
428        /// - semanticType: null
429        /// - encodedOffset: 90
430        /// - encodedLength: 8
431        /// - version: 0
432        #[inline]
433        pub fn last_id(&mut self, value: i64) {
434            let offset = self.offset + 90;
435            self.get_buf_mut().put_i64_at(offset, value);
436        }
437
438        /// primitive field 'numTrades'
439        /// - min value: -9223372036854775807
440        /// - max value: 9223372036854775807
441        /// - null value: -9223372036854775808_i64
442        /// - characterEncoding: null
443        /// - semanticType: null
444        /// - encodedOffset: 98
445        /// - encodedLength: 8
446        /// - version: 0
447        #[inline]
448        pub fn num_trades(&mut self, value: i64) {
449            let offset = self.offset + 98;
450            self.get_buf_mut().put_i64_at(offset, value);
451        }
452
453        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
454        #[inline]
455        pub fn symbol(&mut self, value: &str) {
456            let limit = self.get_limit();
457            let data_length = value.len();
458            self.set_limit(limit + 1 + data_length);
459            self.get_buf_mut().put_u8_at(limit, data_length as u8);
460            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
461        }
462    }
463} // end encoder
464
465pub mod decoder {
466    use message_header_codec::*;
467
468    use super::*;
469
470    #[derive(Clone, Copy, Debug, Default)]
471    pub struct TickerMiniResponseDecoder<'a> {
472        buf: ReadBuf<'a>,
473        initial_offset: usize,
474        offset: usize,
475        limit: usize,
476        pub acting_block_length: u16,
477        pub acting_version: u16,
478    }
479
480    impl ActingVersion for TickerMiniResponseDecoder<'_> {
481        #[inline]
482        fn acting_version(&self) -> u16 {
483            self.acting_version
484        }
485    }
486
487    impl<'a> Reader<'a> for TickerMiniResponseDecoder<'a> {
488        #[inline]
489        fn get_buf(&self) -> &ReadBuf<'a> {
490            &self.buf
491        }
492    }
493
494    impl<'a> Decoder<'a> for TickerMiniResponseDecoder<'a> {
495        #[inline]
496        fn get_limit(&self) -> usize {
497            self.limit
498        }
499
500        #[inline]
501        fn set_limit(&mut self, limit: usize) {
502            self.limit = limit;
503        }
504    }
505
506    impl<'a> TickerMiniResponseDecoder<'a> {
507        pub fn wrap(
508            mut self,
509            buf: ReadBuf<'a>,
510            offset: usize,
511            acting_block_length: u16,
512            acting_version: u16,
513        ) -> Self {
514            let limit = offset + acting_block_length as usize;
515            self.buf = buf;
516            self.initial_offset = offset;
517            self.offset = offset;
518            self.limit = limit;
519            self.acting_block_length = acting_block_length;
520            self.acting_version = acting_version;
521            self
522        }
523
524        #[inline]
525        pub fn encoded_length(&self) -> usize {
526            self.limit - self.offset
527        }
528
529        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
530            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
531            let acting_block_length = header.block_length();
532            let acting_version = header.version();
533
534            self.wrap(
535                header.parent().unwrap(),
536                offset + message_header_codec::ENCODED_LENGTH,
537                acting_block_length,
538                acting_version,
539            )
540        }
541
542        /// GROUP DECODER (id=100)
543        #[inline]
544        pub fn tickers_decoder(self) -> TickersDecoder<Self> {
545            TickersDecoder::default().wrap(self)
546        }
547    }
548
549    #[derive(Debug, Default)]
550    pub struct TickersDecoder<P> {
551        parent: Option<P>,
552        block_length: u16,
553        count: u32,
554        index: usize,
555        offset: usize,
556    }
557
558    impl<'a, P> ActingVersion for TickersDecoder<P>
559    where
560        P: Reader<'a> + ActingVersion + Default,
561    {
562        #[inline]
563        fn acting_version(&self) -> u16 {
564            self.parent.as_ref().unwrap().acting_version()
565        }
566    }
567
568    impl<'a, P> Reader<'a> for TickersDecoder<P>
569    where
570        P: Reader<'a> + Default,
571    {
572        #[inline]
573        fn get_buf(&self) -> &ReadBuf<'a> {
574            self.parent.as_ref().expect("parent missing").get_buf()
575        }
576    }
577
578    impl<'a, P> Decoder<'a> for TickersDecoder<P>
579    where
580        P: Decoder<'a> + ActingVersion + Default,
581    {
582        #[inline]
583        fn get_limit(&self) -> usize {
584            self.parent.as_ref().expect("parent missing").get_limit()
585        }
586
587        #[inline]
588        fn set_limit(&mut self, limit: usize) {
589            self.parent
590                .as_mut()
591                .expect("parent missing")
592                .set_limit(limit);
593        }
594    }
595
596    impl<'a, P> TickersDecoder<P>
597    where
598        P: Decoder<'a> + ActingVersion + Default,
599    {
600        pub fn wrap(mut self, mut parent: P) -> Self {
601            let initial_offset = parent.get_limit();
602            let block_length = parent.get_buf().get_u16_at(initial_offset);
603            let count = parent.get_buf().get_u32_at(initial_offset + 2);
604            parent.set_limit(initial_offset + 6);
605            self.parent = Some(parent);
606            self.block_length = block_length;
607            self.count = count;
608            self.index = usize::MAX;
609            self.offset = 0;
610            self
611        }
612
613        /// group token - Token{signal=BEGIN_GROUP, name='tickers', referencedName='null', description='null', packageName='null', id=100, version=0, deprecated=0, encodedLength=106, offset=0, componentTokenCount=51, encoding=Encoding{presence=REQUIRED, primitiveType=null, byteOrder=LITTLE_ENDIAN, minValue=null, maxValue=null, nullValue=null, constValue=null, characterEncoding='null', epoch='null', timeUnit=null, semanticType='null'}}
614        #[inline]
615        pub fn parent(&mut self) -> SbeResult<P> {
616            self.parent.take().ok_or(SbeErr::ParentNotSet)
617        }
618
619        #[inline]
620        pub fn acting_version(&mut self) -> u16 {
621            self.parent.as_ref().unwrap().acting_version()
622        }
623
624        #[inline]
625        pub fn count(&self) -> u32 {
626            self.count
627        }
628
629        /// will return Some(current index) when successful otherwise None
630        pub fn advance(&mut self) -> SbeResult<Option<usize>> {
631            let index = self.index.wrapping_add(1);
632            if index >= self.count as usize {
633                return Ok(None);
634            }
635
636            if let Some(parent) = self.parent.as_mut() {
637                self.offset = parent.get_limit();
638                parent.set_limit(self.offset + self.block_length as usize);
639                self.index = index;
640                Ok(Some(index))
641            } else {
642                Err(SbeErr::ParentNotSet)
643            }
644        }
645
646        /// primitive field - 'REQUIRED'
647        #[inline]
648        pub fn price_exponent(&self) -> i8 {
649            self.get_buf().get_i8_at(self.offset)
650        }
651
652        /// primitive field - 'REQUIRED'
653        #[inline]
654        pub fn qty_exponent(&self) -> i8 {
655            self.get_buf().get_i8_at(self.offset + 1)
656        }
657
658        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
659        #[inline]
660        pub fn open_price(&self) -> Option<i64> {
661            let value = self.get_buf().get_i64_at(self.offset + 2);
662            if value == -9223372036854775808_i64 {
663                None
664            } else {
665                Some(value)
666            }
667        }
668
669        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
670        #[inline]
671        pub fn high_price(&self) -> Option<i64> {
672            let value = self.get_buf().get_i64_at(self.offset + 10);
673            if value == -9223372036854775808_i64 {
674                None
675            } else {
676                Some(value)
677            }
678        }
679
680        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
681        #[inline]
682        pub fn low_price(&self) -> Option<i64> {
683            let value = self.get_buf().get_i64_at(self.offset + 18);
684            if value == -9223372036854775808_i64 {
685                None
686            } else {
687                Some(value)
688            }
689        }
690
691        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
692        #[inline]
693        pub fn last_price(&self) -> Option<i64> {
694            let value = self.get_buf().get_i64_at(self.offset + 26);
695            if value == -9223372036854775808_i64 {
696                None
697            } else {
698                Some(value)
699            }
700        }
701
702        #[inline]
703        pub fn volume(&self) -> [u8; 16] {
704            let buf = self.get_buf();
705            ReadBuf::get_bytes_at(buf.data, self.offset + 34)
706        }
707
708        #[inline]
709        pub fn quote_volume(&self) -> [u8; 16] {
710            let buf = self.get_buf();
711            ReadBuf::get_bytes_at(buf.data, self.offset + 50)
712        }
713
714        /// primitive field - 'REQUIRED'
715        #[inline]
716        pub fn open_time(&self) -> i64 {
717            self.get_buf().get_i64_at(self.offset + 66)
718        }
719
720        /// primitive field - 'REQUIRED'
721        #[inline]
722        pub fn close_time(&self) -> i64 {
723            self.get_buf().get_i64_at(self.offset + 74)
724        }
725
726        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
727        #[inline]
728        pub fn first_id(&self) -> Option<i64> {
729            let value = self.get_buf().get_i64_at(self.offset + 82);
730            if value == -9223372036854775808_i64 {
731                None
732            } else {
733                Some(value)
734            }
735        }
736
737        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
738        #[inline]
739        pub fn last_id(&self) -> Option<i64> {
740            let value = self.get_buf().get_i64_at(self.offset + 90);
741            if value == -9223372036854775808_i64 {
742                None
743            } else {
744                Some(value)
745            }
746        }
747
748        /// primitive field - 'REQUIRED'
749        #[inline]
750        pub fn num_trades(&self) -> i64 {
751            self.get_buf().get_i64_at(self.offset + 98)
752        }
753
754        /// VAR_DATA DECODER - character encoding: 'UTF-8'
755        #[inline]
756        pub fn symbol_decoder(&mut self) -> (usize, usize) {
757            let offset = self.parent.as_ref().expect("parent missing").get_limit();
758            let data_length = self.get_buf().get_u8_at(offset) as usize;
759            self.parent
760                .as_mut()
761                .unwrap()
762                .set_limit(offset + 1 + data_length);
763            (offset + 1, data_length)
764        }
765
766        #[inline]
767        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
768            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
769            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
770        }
771    }
772} // end decoder
nautilus_binance/spot/sbe/generated/ticker_mini_response_codec.rs

nautilus_binance/spot/sbe/generated/
ticker_mini_response_codec.rs
