nautilus_binance/spot/sbe/generated/
ticker_full_response_codec.rs

1pub use decoder::TickerFullResponseDecoder;
2pub use encoder::TickerFullResponseEncoder;
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 = 214;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct TickerFullResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for TickerFullResponseEncoder<'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 TickerFullResponseEncoder<'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> TickerFullResponseEncoder<'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            126
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 'priceChange'
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 price_change(&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 'priceChangePercent'
212        /// - min value: -3.4028234663852886E38
213        /// - max value: 3.4028234663852886E38
214        /// - null value: f32::NAN
215        /// - characterEncoding: null
216        /// - semanticType: null
217        /// - encodedOffset: 10
218        /// - encodedLength: 4
219        /// - version: 0
220        #[inline]
221        pub fn price_change_percent(&mut self, value: f32) {
222            let offset = self.offset + 10;
223            self.get_buf_mut().put_f32_at(offset, value);
224        }
225
226        /// primitive field 'weightedAvgPrice'
227        /// - min value: -9223372036854775807
228        /// - max value: 9223372036854775807
229        /// - null value: -9223372036854775808_i64
230        /// - characterEncoding: null
231        /// - semanticType: null
232        /// - encodedOffset: 14
233        /// - encodedLength: 8
234        /// - version: 0
235        #[inline]
236        pub fn weighted_avg_price(&mut self, value: i64) {
237            let offset = self.offset + 14;
238            self.get_buf_mut().put_i64_at(offset, value);
239        }
240
241        /// primitive field 'openPrice'
242        /// - min value: -9223372036854775807
243        /// - max value: 9223372036854775807
244        /// - null value: -9223372036854775808_i64
245        /// - characterEncoding: null
246        /// - semanticType: null
247        /// - encodedOffset: 22
248        /// - encodedLength: 8
249        /// - version: 0
250        #[inline]
251        pub fn open_price(&mut self, value: i64) {
252            let offset = self.offset + 22;
253            self.get_buf_mut().put_i64_at(offset, value);
254        }
255
256        /// primitive field 'highPrice'
257        /// - min value: -9223372036854775807
258        /// - max value: 9223372036854775807
259        /// - null value: -9223372036854775808_i64
260        /// - characterEncoding: null
261        /// - semanticType: null
262        /// - encodedOffset: 30
263        /// - encodedLength: 8
264        /// - version: 0
265        #[inline]
266        pub fn high_price(&mut self, value: i64) {
267            let offset = self.offset + 30;
268            self.get_buf_mut().put_i64_at(offset, value);
269        }
270
271        /// primitive field 'lowPrice'
272        /// - min value: -9223372036854775807
273        /// - max value: 9223372036854775807
274        /// - null value: -9223372036854775808_i64
275        /// - characterEncoding: null
276        /// - semanticType: null
277        /// - encodedOffset: 38
278        /// - encodedLength: 8
279        /// - version: 0
280        #[inline]
281        pub fn low_price(&mut self, value: i64) {
282            let offset = self.offset + 38;
283            self.get_buf_mut().put_i64_at(offset, value);
284        }
285
286        /// primitive field 'lastPrice'
287        /// - min value: -9223372036854775807
288        /// - max value: 9223372036854775807
289        /// - null value: -9223372036854775808_i64
290        /// - characterEncoding: null
291        /// - semanticType: null
292        /// - encodedOffset: 46
293        /// - encodedLength: 8
294        /// - version: 0
295        #[inline]
296        pub fn last_price(&mut self, value: i64) {
297            let offset = self.offset + 46;
298            self.get_buf_mut().put_i64_at(offset, value);
299        }
300
301        #[inline]
302        pub fn volume_at(&mut self, index: usize, value: u8) {
303            let offset = self.offset + 54;
304            let buf = self.get_buf_mut();
305            buf.put_u8_at(offset + index, value);
306        }
307
308        /// primitive array field 'volume'
309        /// - min value: 0
310        /// - max value: 254
311        /// - null value: 0xff_u8
312        /// - characterEncoding: null
313        /// - semanticType: null
314        /// - encodedOffset: 54
315        /// - encodedLength: 16
316        /// - version: 0
317        #[inline]
318        pub fn volume(&mut self, value: &[u8]) {
319            debug_assert_eq!(16, value.len());
320            let offset = self.offset + 54;
321            let buf = self.get_buf_mut();
322            buf.put_slice_at(offset, value);
323        }
324
325        /// primitive array field 'volume' from an Iterator
326        /// - min value: 0
327        /// - max value: 254
328        /// - null value: 0xff_u8
329        /// - characterEncoding: null
330        /// - semanticType: null
331        /// - encodedOffset: 54
332        /// - encodedLength: 16
333        /// - version: 0
334        #[inline]
335        pub fn volume_from_iter(&mut self, iter: impl Iterator<Item = u8>) {
336            let offset = self.offset + 54;
337            let buf = self.get_buf_mut();
338            for (i, v) in iter.enumerate() {
339                buf.put_u8_at(offset + i, v);
340            }
341        }
342
343        /// primitive array field 'volume' with zero padding
344        /// - min value: 0
345        /// - max value: 254
346        /// - null value: 0xff_u8
347        /// - characterEncoding: null
348        /// - semanticType: null
349        /// - encodedOffset: 54
350        /// - encodedLength: 16
351        /// - version: 0
352        #[inline]
353        pub fn volume_zero_padded(&mut self, value: &[u8]) {
354            let iter = value
355                .iter()
356                .copied()
357                .chain(std::iter::repeat(0_u8))
358                .take(16);
359            self.volume_from_iter(iter);
360        }
361
362        #[inline]
363        pub fn quote_volume_at(&mut self, index: usize, value: u8) {
364            let offset = self.offset + 70;
365            let buf = self.get_buf_mut();
366            buf.put_u8_at(offset + index, value);
367        }
368
369        /// primitive array field 'quoteVolume'
370        /// - min value: 0
371        /// - max value: 254
372        /// - null value: 0xff_u8
373        /// - characterEncoding: null
374        /// - semanticType: null
375        /// - encodedOffset: 70
376        /// - encodedLength: 16
377        /// - version: 0
378        #[inline]
379        pub fn quote_volume(&mut self, value: &[u8]) {
380            debug_assert_eq!(16, value.len());
381            let offset = self.offset + 70;
382            let buf = self.get_buf_mut();
383            buf.put_slice_at(offset, value);
384        }
385
386        /// primitive array field 'quoteVolume' from an Iterator
387        /// - min value: 0
388        /// - max value: 254
389        /// - null value: 0xff_u8
390        /// - characterEncoding: null
391        /// - semanticType: null
392        /// - encodedOffset: 70
393        /// - encodedLength: 16
394        /// - version: 0
395        #[inline]
396        pub fn quote_volume_from_iter(&mut self, iter: impl Iterator<Item = u8>) {
397            let offset = self.offset + 70;
398            let buf = self.get_buf_mut();
399            for (i, v) in iter.enumerate() {
400                buf.put_u8_at(offset + i, v);
401            }
402        }
403
404        /// primitive array field 'quoteVolume' with zero padding
405        /// - min value: 0
406        /// - max value: 254
407        /// - null value: 0xff_u8
408        /// - characterEncoding: null
409        /// - semanticType: null
410        /// - encodedOffset: 70
411        /// - encodedLength: 16
412        /// - version: 0
413        #[inline]
414        pub fn quote_volume_zero_padded(&mut self, value: &[u8]) {
415            let iter = value
416                .iter()
417                .copied()
418                .chain(std::iter::repeat(0_u8))
419                .take(16);
420            self.quote_volume_from_iter(iter);
421        }
422
423        /// primitive field 'openTime'
424        /// - min value: -9223372036854775807
425        /// - max value: 9223372036854775807
426        /// - null value: -9223372036854775808_i64
427        /// - characterEncoding: null
428        /// - semanticType: null
429        /// - encodedOffset: 86
430        /// - encodedLength: 8
431        /// - version: 0
432        #[inline]
433        pub fn open_time(&mut self, value: i64) {
434            let offset = self.offset + 86;
435            self.get_buf_mut().put_i64_at(offset, value);
436        }
437
438        /// primitive field 'closeTime'
439        /// - min value: -9223372036854775807
440        /// - max value: 9223372036854775807
441        /// - null value: -9223372036854775808_i64
442        /// - characterEncoding: null
443        /// - semanticType: null
444        /// - encodedOffset: 94
445        /// - encodedLength: 8
446        /// - version: 0
447        #[inline]
448        pub fn close_time(&mut self, value: i64) {
449            let offset = self.offset + 94;
450            self.get_buf_mut().put_i64_at(offset, value);
451        }
452
453        /// primitive field 'firstId'
454        /// - min value: -9223372036854775807
455        /// - max value: 9223372036854775807
456        /// - null value: -9223372036854775808_i64
457        /// - characterEncoding: null
458        /// - semanticType: null
459        /// - encodedOffset: 102
460        /// - encodedLength: 8
461        /// - version: 0
462        #[inline]
463        pub fn first_id(&mut self, value: i64) {
464            let offset = self.offset + 102;
465            self.get_buf_mut().put_i64_at(offset, value);
466        }
467
468        /// primitive field 'lastId'
469        /// - min value: -9223372036854775807
470        /// - max value: 9223372036854775807
471        /// - null value: -9223372036854775808_i64
472        /// - characterEncoding: null
473        /// - semanticType: null
474        /// - encodedOffset: 110
475        /// - encodedLength: 8
476        /// - version: 0
477        #[inline]
478        pub fn last_id(&mut self, value: i64) {
479            let offset = self.offset + 110;
480            self.get_buf_mut().put_i64_at(offset, value);
481        }
482
483        /// primitive field 'numTrades'
484        /// - min value: -9223372036854775807
485        /// - max value: 9223372036854775807
486        /// - null value: -9223372036854775808_i64
487        /// - characterEncoding: null
488        /// - semanticType: null
489        /// - encodedOffset: 118
490        /// - encodedLength: 8
491        /// - version: 0
492        #[inline]
493        pub fn num_trades(&mut self, value: i64) {
494            let offset = self.offset + 118;
495            self.get_buf_mut().put_i64_at(offset, value);
496        }
497
498        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
499        #[inline]
500        pub fn symbol(&mut self, value: &str) {
501            let limit = self.get_limit();
502            let data_length = value.len();
503            self.set_limit(limit + 1 + data_length);
504            self.get_buf_mut().put_u8_at(limit, data_length as u8);
505            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
506        }
507    }
508} // end encoder
509
510pub mod decoder {
511    use message_header_codec::*;
512
513    use super::*;
514
515    #[derive(Clone, Copy, Debug, Default)]
516    pub struct TickerFullResponseDecoder<'a> {
517        buf: ReadBuf<'a>,
518        initial_offset: usize,
519        offset: usize,
520        limit: usize,
521        pub acting_block_length: u16,
522        pub acting_version: u16,
523    }
524
525    impl ActingVersion for TickerFullResponseDecoder<'_> {
526        #[inline]
527        fn acting_version(&self) -> u16 {
528            self.acting_version
529        }
530    }
531
532    impl<'a> Reader<'a> for TickerFullResponseDecoder<'a> {
533        #[inline]
534        fn get_buf(&self) -> &ReadBuf<'a> {
535            &self.buf
536        }
537    }
538
539    impl<'a> Decoder<'a> for TickerFullResponseDecoder<'a> {
540        #[inline]
541        fn get_limit(&self) -> usize {
542            self.limit
543        }
544
545        #[inline]
546        fn set_limit(&mut self, limit: usize) {
547            self.limit = limit;
548        }
549    }
550
551    impl<'a> TickerFullResponseDecoder<'a> {
552        pub fn wrap(
553            mut self,
554            buf: ReadBuf<'a>,
555            offset: usize,
556            acting_block_length: u16,
557            acting_version: u16,
558        ) -> Self {
559            let limit = offset + acting_block_length as usize;
560            self.buf = buf;
561            self.initial_offset = offset;
562            self.offset = offset;
563            self.limit = limit;
564            self.acting_block_length = acting_block_length;
565            self.acting_version = acting_version;
566            self
567        }
568
569        #[inline]
570        pub fn encoded_length(&self) -> usize {
571            self.limit - self.offset
572        }
573
574        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
575            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
576            let acting_block_length = header.block_length();
577            let acting_version = header.version();
578
579            self.wrap(
580                header.parent().unwrap(),
581                offset + message_header_codec::ENCODED_LENGTH,
582                acting_block_length,
583                acting_version,
584            )
585        }
586
587        /// GROUP DECODER (id=100)
588        #[inline]
589        pub fn tickers_decoder(self) -> TickersDecoder<Self> {
590            TickersDecoder::default().wrap(self)
591        }
592    }
593
594    #[derive(Debug, Default)]
595    pub struct TickersDecoder<P> {
596        parent: Option<P>,
597        block_length: u16,
598        count: u32,
599        index: usize,
600        offset: usize,
601    }
602
603    impl<'a, P> ActingVersion for TickersDecoder<P>
604    where
605        P: Reader<'a> + ActingVersion + Default,
606    {
607        #[inline]
608        fn acting_version(&self) -> u16 {
609            self.parent.as_ref().unwrap().acting_version()
610        }
611    }
612
613    impl<'a, P> Reader<'a> for TickersDecoder<P>
614    where
615        P: Reader<'a> + Default,
616    {
617        #[inline]
618        fn get_buf(&self) -> &ReadBuf<'a> {
619            self.parent.as_ref().expect("parent missing").get_buf()
620        }
621    }
622
623    impl<'a, P> Decoder<'a> for TickersDecoder<P>
624    where
625        P: Decoder<'a> + ActingVersion + Default,
626    {
627        #[inline]
628        fn get_limit(&self) -> usize {
629            self.parent.as_ref().expect("parent missing").get_limit()
630        }
631
632        #[inline]
633        fn set_limit(&mut self, limit: usize) {
634            self.parent
635                .as_mut()
636                .expect("parent missing")
637                .set_limit(limit);
638        }
639    }
640
641    impl<'a, P> TickersDecoder<P>
642    where
643        P: Decoder<'a> + ActingVersion + Default,
644    {
645        pub fn wrap(mut self, mut parent: P) -> Self {
646            let initial_offset = parent.get_limit();
647            let block_length = parent.get_buf().get_u16_at(initial_offset);
648            let count = parent.get_buf().get_u32_at(initial_offset + 2);
649            parent.set_limit(initial_offset + 6);
650            self.parent = Some(parent);
651            self.block_length = block_length;
652            self.count = count;
653            self.index = usize::MAX;
654            self.offset = 0;
655            self
656        }
657
658        /// group token - Token{signal=BEGIN_GROUP, name='tickers', referencedName='null', description='null', packageName='null', id=100, version=0, deprecated=0, encodedLength=126, offset=0, componentTokenCount=60, 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'}}
659        #[inline]
660        pub fn parent(&mut self) -> SbeResult<P> {
661            self.parent.take().ok_or(SbeErr::ParentNotSet)
662        }
663
664        #[inline]
665        pub fn acting_version(&mut self) -> u16 {
666            self.parent.as_ref().unwrap().acting_version()
667        }
668
669        #[inline]
670        pub fn count(&self) -> u32 {
671            self.count
672        }
673
674        /// will return Some(current index) when successful otherwise None
675        pub fn advance(&mut self) -> SbeResult<Option<usize>> {
676            let index = self.index.wrapping_add(1);
677            if index >= self.count as usize {
678                return Ok(None);
679            }
680
681            if let Some(parent) = self.parent.as_mut() {
682                self.offset = parent.get_limit();
683                parent.set_limit(self.offset + self.block_length as usize);
684                self.index = index;
685                Ok(Some(index))
686            } else {
687                Err(SbeErr::ParentNotSet)
688            }
689        }
690
691        /// primitive field - 'REQUIRED'
692        #[inline]
693        pub fn price_exponent(&self) -> i8 {
694            self.get_buf().get_i8_at(self.offset)
695        }
696
697        /// primitive field - 'REQUIRED'
698        #[inline]
699        pub fn qty_exponent(&self) -> i8 {
700            self.get_buf().get_i8_at(self.offset + 1)
701        }
702
703        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
704        #[inline]
705        pub fn price_change(&self) -> Option<i64> {
706            let value = self.get_buf().get_i64_at(self.offset + 2);
707            if value == -9223372036854775808_i64 {
708                None
709            } else {
710                Some(value)
711            }
712        }
713
714        /// primitive field - 'OPTIONAL' { null_value: 'f32::NAN' }
715        #[inline]
716        pub fn price_change_percent(&self) -> Option<f32> {
717            let value = self.get_buf().get_f32_at(self.offset + 10);
718            if value.is_nan() { None } else { Some(value) }
719        }
720
721        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
722        #[inline]
723        pub fn weighted_avg_price(&self) -> Option<i64> {
724            let value = self.get_buf().get_i64_at(self.offset + 14);
725            if value == -9223372036854775808_i64 {
726                None
727            } else {
728                Some(value)
729            }
730        }
731
732        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
733        #[inline]
734        pub fn open_price(&self) -> Option<i64> {
735            let value = self.get_buf().get_i64_at(self.offset + 22);
736            if value == -9223372036854775808_i64 {
737                None
738            } else {
739                Some(value)
740            }
741        }
742
743        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
744        #[inline]
745        pub fn high_price(&self) -> Option<i64> {
746            let value = self.get_buf().get_i64_at(self.offset + 30);
747            if value == -9223372036854775808_i64 {
748                None
749            } else {
750                Some(value)
751            }
752        }
753
754        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
755        #[inline]
756        pub fn low_price(&self) -> Option<i64> {
757            let value = self.get_buf().get_i64_at(self.offset + 38);
758            if value == -9223372036854775808_i64 {
759                None
760            } else {
761                Some(value)
762            }
763        }
764
765        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
766        #[inline]
767        pub fn last_price(&self) -> Option<i64> {
768            let value = self.get_buf().get_i64_at(self.offset + 46);
769            if value == -9223372036854775808_i64 {
770                None
771            } else {
772                Some(value)
773            }
774        }
775
776        #[inline]
777        pub fn volume(&self) -> [u8; 16] {
778            let buf = self.get_buf();
779            ReadBuf::get_bytes_at(buf.data, self.offset + 54)
780        }
781
782        #[inline]
783        pub fn quote_volume(&self) -> [u8; 16] {
784            let buf = self.get_buf();
785            ReadBuf::get_bytes_at(buf.data, self.offset + 70)
786        }
787
788        /// primitive field - 'REQUIRED'
789        #[inline]
790        pub fn open_time(&self) -> i64 {
791            self.get_buf().get_i64_at(self.offset + 86)
792        }
793
794        /// primitive field - 'REQUIRED'
795        #[inline]
796        pub fn close_time(&self) -> i64 {
797            self.get_buf().get_i64_at(self.offset + 94)
798        }
799
800        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
801        #[inline]
802        pub fn first_id(&self) -> Option<i64> {
803            let value = self.get_buf().get_i64_at(self.offset + 102);
804            if value == -9223372036854775808_i64 {
805                None
806            } else {
807                Some(value)
808            }
809        }
810
811        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
812        #[inline]
813        pub fn last_id(&self) -> Option<i64> {
814            let value = self.get_buf().get_i64_at(self.offset + 110);
815            if value == -9223372036854775808_i64 {
816                None
817            } else {
818                Some(value)
819            }
820        }
821
822        /// primitive field - 'REQUIRED'
823        #[inline]
824        pub fn num_trades(&self) -> i64 {
825            self.get_buf().get_i64_at(self.offset + 118)
826        }
827
828        /// VAR_DATA DECODER - character encoding: 'UTF-8'
829        #[inline]
830        pub fn symbol_decoder(&mut self) -> (usize, usize) {
831            let offset = self.parent.as_ref().expect("parent missing").get_limit();
832            let data_length = self.get_buf().get_u8_at(offset) as usize;
833            self.parent
834                .as_mut()
835                .unwrap()
836                .set_limit(offset + 1 + data_length);
837            (offset + 1, data_length)
838        }
839
840        #[inline]
841        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
842            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
843            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
844        }
845    }
846} // end decoder
nautilus_binance/spot/sbe/generated/ticker_full_response_codec.rs

nautilus_binance/spot/sbe/generated/
ticker_full_response_codec.rs
