nautilus_binance/spot/sbe/generated/
orders_response_codec.rs

1pub use decoder::OrdersResponseDecoder;
2pub use encoder::OrdersResponseEncoder;
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 = 308;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct OrdersResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for OrdersResponseEncoder<'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 OrdersResponseEncoder<'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> OrdersResponseEncoder<'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 orders_encoder(
69            self,
70            count: u32,
71            orders_encoder: OrdersEncoder<Self>,
72        ) -> OrdersEncoder<Self> {
73            orders_encoder.wrap(self, count)
74        }
75    }
76
77    #[derive(Debug, Default)]
78    pub struct OrdersEncoder<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 OrdersEncoder<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 OrdersEncoder<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> OrdersEncoder<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            163
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 'orderId'
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 order_id(&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 'orderListId'
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 order_list_id(&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 'price'
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 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 'origQty'
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 orig_qty(&mut self, value: i64) {
252            let offset = self.offset + 26;
253            self.get_buf_mut().put_i64_at(offset, value);
254        }
255
256        /// primitive field 'executedQty'
257        /// - min value: -9223372036854775807
258        /// - max value: 9223372036854775807
259        /// - null value: -9223372036854775808_i64
260        /// - characterEncoding: null
261        /// - semanticType: null
262        /// - encodedOffset: 34
263        /// - encodedLength: 8
264        /// - version: 0
265        #[inline]
266        pub fn executed_qty(&mut self, value: i64) {
267            let offset = self.offset + 34;
268            self.get_buf_mut().put_i64_at(offset, value);
269        }
270
271        /// primitive field 'cummulativeQuoteQty'
272        /// - min value: -9223372036854775807
273        /// - max value: 9223372036854775807
274        /// - null value: -9223372036854775808_i64
275        /// - characterEncoding: null
276        /// - semanticType: null
277        /// - encodedOffset: 42
278        /// - encodedLength: 8
279        /// - version: 0
280        #[inline]
281        pub fn cummulative_quote_qty(&mut self, value: i64) {
282            let offset = self.offset + 42;
283            self.get_buf_mut().put_i64_at(offset, value);
284        }
285
286        /// REQUIRED enum
287        #[inline]
288        pub fn status(&mut self, value: order_status::OrderStatus) {
289            let offset = self.offset + 50;
290            self.get_buf_mut().put_u8_at(offset, value as u8)
291        }
292
293        /// REQUIRED enum
294        #[inline]
295        pub fn time_in_force(&mut self, value: time_in_force::TimeInForce) {
296            let offset = self.offset + 51;
297            self.get_buf_mut().put_u8_at(offset, value as u8)
298        }
299
300        /// REQUIRED enum
301        #[inline]
302        pub fn order_type(&mut self, value: order_type::OrderType) {
303            let offset = self.offset + 52;
304            self.get_buf_mut().put_u8_at(offset, value as u8)
305        }
306
307        /// REQUIRED enum
308        #[inline]
309        pub fn side(&mut self, value: order_side::OrderSide) {
310            let offset = self.offset + 53;
311            self.get_buf_mut().put_u8_at(offset, value as u8)
312        }
313
314        /// primitive field 'stopPrice'
315        /// - min value: -9223372036854775807
316        /// - max value: 9223372036854775807
317        /// - null value: -9223372036854775808_i64
318        /// - characterEncoding: null
319        /// - semanticType: null
320        /// - encodedOffset: 54
321        /// - encodedLength: 8
322        /// - version: 0
323        #[inline]
324        pub fn stop_price(&mut self, value: i64) {
325            let offset = self.offset + 54;
326            self.get_buf_mut().put_i64_at(offset, value);
327        }
328
329        /// primitive field 'trailingDelta'
330        /// - min value: -9223372036854775807
331        /// - max value: 9223372036854775807
332        /// - null value: -9223372036854775808_i64
333        /// - characterEncoding: null
334        /// - semanticType: null
335        /// - encodedOffset: 62
336        /// - encodedLength: 8
337        /// - version: 0
338        #[inline]
339        pub fn trailing_delta(&mut self, value: i64) {
340            let offset = self.offset + 62;
341            self.get_buf_mut().put_i64_at(offset, value);
342        }
343
344        /// primitive field 'trailingTime'
345        /// - min value: -9223372036854775807
346        /// - max value: 9223372036854775807
347        /// - null value: -9223372036854775808_i64
348        /// - characterEncoding: null
349        /// - semanticType: null
350        /// - encodedOffset: 70
351        /// - encodedLength: 8
352        /// - version: 0
353        #[inline]
354        pub fn trailing_time(&mut self, value: i64) {
355            let offset = self.offset + 70;
356            self.get_buf_mut().put_i64_at(offset, value);
357        }
358
359        /// primitive field 'icebergQty'
360        /// - min value: -9223372036854775807
361        /// - max value: 9223372036854775807
362        /// - null value: -9223372036854775808_i64
363        /// - characterEncoding: null
364        /// - semanticType: null
365        /// - encodedOffset: 78
366        /// - encodedLength: 8
367        /// - version: 0
368        #[inline]
369        pub fn iceberg_qty(&mut self, value: i64) {
370            let offset = self.offset + 78;
371            self.get_buf_mut().put_i64_at(offset, value);
372        }
373
374        /// primitive field 'time'
375        /// - min value: -9223372036854775807
376        /// - max value: 9223372036854775807
377        /// - null value: -9223372036854775808_i64
378        /// - characterEncoding: null
379        /// - semanticType: null
380        /// - encodedOffset: 86
381        /// - encodedLength: 8
382        /// - version: 0
383        #[inline]
384        pub fn time(&mut self, value: i64) {
385            let offset = self.offset + 86;
386            self.get_buf_mut().put_i64_at(offset, value);
387        }
388
389        /// primitive field 'updateTime'
390        /// - min value: -9223372036854775807
391        /// - max value: 9223372036854775807
392        /// - null value: -9223372036854775808_i64
393        /// - characterEncoding: null
394        /// - semanticType: null
395        /// - encodedOffset: 94
396        /// - encodedLength: 8
397        /// - version: 0
398        #[inline]
399        pub fn update_time(&mut self, value: i64) {
400            let offset = self.offset + 94;
401            self.get_buf_mut().put_i64_at(offset, value);
402        }
403
404        /// REQUIRED enum
405        #[inline]
406        pub fn is_working(&mut self, value: bool_enum::BoolEnum) {
407            let offset = self.offset + 102;
408            self.get_buf_mut().put_u8_at(offset, value as u8)
409        }
410
411        /// primitive field 'workingTime'
412        /// - min value: -9223372036854775807
413        /// - max value: 9223372036854775807
414        /// - null value: -9223372036854775808_i64
415        /// - characterEncoding: null
416        /// - semanticType: null
417        /// - encodedOffset: 103
418        /// - encodedLength: 8
419        /// - version: 0
420        #[inline]
421        pub fn working_time(&mut self, value: i64) {
422            let offset = self.offset + 103;
423            self.get_buf_mut().put_i64_at(offset, value);
424        }
425
426        /// primitive field 'origQuoteOrderQty'
427        /// - min value: -9223372036854775807
428        /// - max value: 9223372036854775807
429        /// - null value: -9223372036854775808_i64
430        /// - characterEncoding: null
431        /// - semanticType: null
432        /// - encodedOffset: 111
433        /// - encodedLength: 8
434        /// - version: 0
435        #[inline]
436        pub fn orig_quote_order_qty(&mut self, value: i64) {
437            let offset = self.offset + 111;
438            self.get_buf_mut().put_i64_at(offset, value);
439        }
440
441        /// primitive field 'strategyId'
442        /// - min value: -9223372036854775807
443        /// - max value: 9223372036854775807
444        /// - null value: -9223372036854775808_i64
445        /// - characterEncoding: null
446        /// - semanticType: null
447        /// - encodedOffset: 119
448        /// - encodedLength: 8
449        /// - version: 0
450        #[inline]
451        pub fn strategy_id(&mut self, value: i64) {
452            let offset = self.offset + 119;
453            self.get_buf_mut().put_i64_at(offset, value);
454        }
455
456        /// primitive field 'strategyType'
457        /// - min value: -2147483647
458        /// - max value: 2147483647
459        /// - null value: -2147483648_i32
460        /// - characterEncoding: null
461        /// - semanticType: null
462        /// - encodedOffset: 127
463        /// - encodedLength: 4
464        /// - version: 0
465        #[inline]
466        pub fn strategy_type(&mut self, value: i32) {
467            let offset = self.offset + 127;
468            self.get_buf_mut().put_i32_at(offset, value);
469        }
470
471        /// REQUIRED enum
472        #[inline]
473        pub fn order_capacity(&mut self, value: order_capacity::OrderCapacity) {
474            let offset = self.offset + 131;
475            self.get_buf_mut().put_u8_at(offset, value as u8)
476        }
477
478        /// REQUIRED enum
479        #[inline]
480        pub fn working_floor(&mut self, value: floor::Floor) {
481            let offset = self.offset + 132;
482            self.get_buf_mut().put_u8_at(offset, value as u8)
483        }
484
485        /// REQUIRED enum
486        #[inline]
487        pub fn self_trade_prevention_mode(
488            &mut self,
489            value: self_trade_prevention_mode::SelfTradePreventionMode,
490        ) {
491            let offset = self.offset + 133;
492            self.get_buf_mut().put_u8_at(offset, value as u8)
493        }
494
495        /// primitive field 'preventedMatchId'
496        /// - min value: -9223372036854775807
497        /// - max value: 9223372036854775807
498        /// - null value: -9223372036854775808_i64
499        /// - characterEncoding: null
500        /// - semanticType: null
501        /// - encodedOffset: 134
502        /// - encodedLength: 8
503        /// - version: 0
504        #[inline]
505        pub fn prevented_match_id(&mut self, value: i64) {
506            let offset = self.offset + 134;
507            self.get_buf_mut().put_i64_at(offset, value);
508        }
509
510        /// primitive field 'preventedQuantity'
511        /// - min value: -9223372036854775807
512        /// - max value: 9223372036854775807
513        /// - null value: -9223372036854775808_i64
514        /// - characterEncoding: null
515        /// - semanticType: null
516        /// - encodedOffset: 142
517        /// - encodedLength: 8
518        /// - version: 0
519        #[inline]
520        pub fn prevented_quantity(&mut self, value: i64) {
521            let offset = self.offset + 142;
522            self.get_buf_mut().put_i64_at(offset, value);
523        }
524
525        /// REQUIRED enum
526        #[inline]
527        pub fn used_sor(&mut self, value: bool_enum::BoolEnum) {
528            let offset = self.offset + 150;
529            self.get_buf_mut().put_u8_at(offset, value as u8)
530        }
531
532        /// REQUIRED enum
533        #[inline]
534        pub fn peg_price_type(&mut self, value: peg_price_type::PegPriceType) {
535            let offset = self.offset + 151;
536            self.get_buf_mut().put_u8_at(offset, value as u8)
537        }
538
539        /// REQUIRED enum
540        #[inline]
541        pub fn peg_offset_type(&mut self, value: peg_offset_type::PegOffsetType) {
542            let offset = self.offset + 152;
543            self.get_buf_mut().put_u8_at(offset, value as u8)
544        }
545
546        /// primitive field 'pegOffsetValue'
547        /// - min value: 0
548        /// - max value: 254
549        /// - null value: 0xff_u8
550        /// - characterEncoding: null
551        /// - semanticType: null
552        /// - encodedOffset: 153
553        /// - encodedLength: 1
554        /// - version: 1
555        #[inline]
556        pub fn peg_offset_value(&mut self, value: u8) {
557            let offset = self.offset + 153;
558            self.get_buf_mut().put_u8_at(offset, value);
559        }
560
561        /// primitive field 'peggedPrice'
562        /// - min value: -9223372036854775807
563        /// - max value: 9223372036854775807
564        /// - null value: -9223372036854775808_i64
565        /// - characterEncoding: null
566        /// - semanticType: null
567        /// - encodedOffset: 154
568        /// - encodedLength: 8
569        /// - version: 1
570        #[inline]
571        pub fn pegged_price(&mut self, value: i64) {
572            let offset = self.offset + 154;
573            self.get_buf_mut().put_i64_at(offset, value);
574        }
575
576        /// REQUIRED enum
577        #[inline]
578        pub fn expiry_reason(&mut self, value: expiry_reason::ExpiryReason) {
579            let offset = self.offset + 162;
580            self.get_buf_mut().put_u8_at(offset, value as u8)
581        }
582
583        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
584        #[inline]
585        pub fn symbol(&mut self, value: &str) {
586            let limit = self.get_limit();
587            let data_length = value.len();
588            self.set_limit(limit + 1 + data_length);
589            self.get_buf_mut().put_u8_at(limit, data_length as u8);
590            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
591        }
592
593        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
594        #[inline]
595        pub fn client_order_id(&mut self, value: &str) {
596            let limit = self.get_limit();
597            let data_length = value.len();
598            self.set_limit(limit + 1 + data_length);
599            self.get_buf_mut().put_u8_at(limit, data_length as u8);
600            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
601        }
602    }
603} // end encoder
604
605pub mod decoder {
606    use message_header_codec::*;
607
608    use super::*;
609
610    #[derive(Clone, Copy, Debug, Default)]
611    pub struct OrdersResponseDecoder<'a> {
612        buf: ReadBuf<'a>,
613        initial_offset: usize,
614        offset: usize,
615        limit: usize,
616        pub acting_block_length: u16,
617        pub acting_version: u16,
618    }
619
620    impl ActingVersion for OrdersResponseDecoder<'_> {
621        #[inline]
622        fn acting_version(&self) -> u16 {
623            self.acting_version
624        }
625    }
626
627    impl<'a> Reader<'a> for OrdersResponseDecoder<'a> {
628        #[inline]
629        fn get_buf(&self) -> &ReadBuf<'a> {
630            &self.buf
631        }
632    }
633
634    impl<'a> Decoder<'a> for OrdersResponseDecoder<'a> {
635        #[inline]
636        fn get_limit(&self) -> usize {
637            self.limit
638        }
639
640        #[inline]
641        fn set_limit(&mut self, limit: usize) {
642            self.limit = limit;
643        }
644    }
645
646    impl<'a> OrdersResponseDecoder<'a> {
647        pub fn wrap(
648            mut self,
649            buf: ReadBuf<'a>,
650            offset: usize,
651            acting_block_length: u16,
652            acting_version: u16,
653        ) -> Self {
654            let limit = offset + acting_block_length as usize;
655            self.buf = buf;
656            self.initial_offset = offset;
657            self.offset = offset;
658            self.limit = limit;
659            self.acting_block_length = acting_block_length;
660            self.acting_version = acting_version;
661            self
662        }
663
664        #[inline]
665        pub fn encoded_length(&self) -> usize {
666            self.limit - self.offset
667        }
668
669        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
670            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
671            let acting_block_length = header.block_length();
672            let acting_version = header.version();
673
674            self.wrap(
675                header.parent().unwrap(),
676                offset + message_header_codec::ENCODED_LENGTH,
677                acting_block_length,
678                acting_version,
679            )
680        }
681
682        /// GROUP DECODER (id=100)
683        #[inline]
684        pub fn orders_decoder(self) -> OrdersDecoder<Self> {
685            OrdersDecoder::default().wrap(self)
686        }
687    }
688
689    #[derive(Debug, Default)]
690    pub struct OrdersDecoder<P> {
691        parent: Option<P>,
692        block_length: u16,
693        count: u32,
694        index: usize,
695        offset: usize,
696    }
697
698    impl<'a, P> ActingVersion for OrdersDecoder<P>
699    where
700        P: Reader<'a> + ActingVersion + Default,
701    {
702        #[inline]
703        fn acting_version(&self) -> u16 {
704            self.parent.as_ref().unwrap().acting_version()
705        }
706    }
707
708    impl<'a, P> Reader<'a> for OrdersDecoder<P>
709    where
710        P: Reader<'a> + Default,
711    {
712        #[inline]
713        fn get_buf(&self) -> &ReadBuf<'a> {
714            self.parent.as_ref().expect("parent missing").get_buf()
715        }
716    }
717
718    impl<'a, P> Decoder<'a> for OrdersDecoder<P>
719    where
720        P: Decoder<'a> + ActingVersion + Default,
721    {
722        #[inline]
723        fn get_limit(&self) -> usize {
724            self.parent.as_ref().expect("parent missing").get_limit()
725        }
726
727        #[inline]
728        fn set_limit(&mut self, limit: usize) {
729            self.parent
730                .as_mut()
731                .expect("parent missing")
732                .set_limit(limit);
733        }
734    }
735
736    impl<'a, P> OrdersDecoder<P>
737    where
738        P: Decoder<'a> + ActingVersion + Default,
739    {
740        pub fn wrap(mut self, mut parent: P) -> Self {
741            let initial_offset = parent.get_limit();
742            let block_length = parent.get_buf().get_u16_at(initial_offset);
743            let count = parent.get_buf().get_u32_at(initial_offset + 2);
744            parent.set_limit(initial_offset + 6);
745            self.parent = Some(parent);
746            self.block_length = block_length;
747            self.count = count;
748            self.index = usize::MAX;
749            self.offset = 0;
750            self
751        }
752
753        /// group token - Token{signal=BEGIN_GROUP, name='orders', referencedName='null', description='null', packageName='null', id=100, version=0, deprecated=0, encodedLength=163, offset=0, componentTokenCount=190, 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'}}
754        #[inline]
755        pub fn parent(&mut self) -> SbeResult<P> {
756            self.parent.take().ok_or(SbeErr::ParentNotSet)
757        }
758
759        #[inline]
760        pub fn acting_version(&mut self) -> u16 {
761            self.parent.as_ref().unwrap().acting_version()
762        }
763
764        #[inline]
765        pub fn count(&self) -> u32 {
766            self.count
767        }
768
769        /// will return Some(current index) when successful otherwise None
770        pub fn advance(&mut self) -> SbeResult<Option<usize>> {
771            let index = self.index.wrapping_add(1);
772            if index >= self.count as usize {
773                return Ok(None);
774            }
775
776            if let Some(parent) = self.parent.as_mut() {
777                self.offset = parent.get_limit();
778                parent.set_limit(self.offset + self.block_length as usize);
779                self.index = index;
780                Ok(Some(index))
781            } else {
782                Err(SbeErr::ParentNotSet)
783            }
784        }
785
786        /// primitive field - 'REQUIRED'
787        #[inline]
788        pub fn price_exponent(&self) -> i8 {
789            self.get_buf().get_i8_at(self.offset)
790        }
791
792        /// primitive field - 'REQUIRED'
793        #[inline]
794        pub fn qty_exponent(&self) -> i8 {
795            self.get_buf().get_i8_at(self.offset + 1)
796        }
797
798        /// primitive field - 'REQUIRED'
799        #[inline]
800        pub fn order_id(&self) -> i64 {
801            self.get_buf().get_i64_at(self.offset + 2)
802        }
803
804        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
805        #[inline]
806        pub fn order_list_id(&self) -> Option<i64> {
807            let value = self.get_buf().get_i64_at(self.offset + 10);
808            if value == -9223372036854775808_i64 {
809                None
810            } else {
811                Some(value)
812            }
813        }
814
815        /// primitive field - 'REQUIRED'
816        #[inline]
817        pub fn price(&self) -> i64 {
818            self.get_buf().get_i64_at(self.offset + 18)
819        }
820
821        /// primitive field - 'REQUIRED'
822        #[inline]
823        pub fn orig_qty(&self) -> i64 {
824            self.get_buf().get_i64_at(self.offset + 26)
825        }
826
827        /// primitive field - 'REQUIRED'
828        #[inline]
829        pub fn executed_qty(&self) -> i64 {
830            self.get_buf().get_i64_at(self.offset + 34)
831        }
832
833        /// primitive field - 'REQUIRED'
834        #[inline]
835        pub fn cummulative_quote_qty(&self) -> i64 {
836            self.get_buf().get_i64_at(self.offset + 42)
837        }
838
839        /// REQUIRED enum
840        #[inline]
841        pub fn status(&self) -> order_status::OrderStatus {
842            self.get_buf().get_u8_at(self.offset + 50).into()
843        }
844
845        /// REQUIRED enum
846        #[inline]
847        pub fn time_in_force(&self) -> time_in_force::TimeInForce {
848            self.get_buf().get_u8_at(self.offset + 51).into()
849        }
850
851        /// REQUIRED enum
852        #[inline]
853        pub fn order_type(&self) -> order_type::OrderType {
854            self.get_buf().get_u8_at(self.offset + 52).into()
855        }
856
857        /// REQUIRED enum
858        #[inline]
859        pub fn side(&self) -> order_side::OrderSide {
860            self.get_buf().get_u8_at(self.offset + 53).into()
861        }
862
863        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
864        #[inline]
865        pub fn stop_price(&self) -> Option<i64> {
866            let value = self.get_buf().get_i64_at(self.offset + 54);
867            if value == -9223372036854775808_i64 {
868                None
869            } else {
870                Some(value)
871            }
872        }
873
874        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
875        #[inline]
876        pub fn trailing_delta(&self) -> Option<i64> {
877            let value = self.get_buf().get_i64_at(self.offset + 62);
878            if value == -9223372036854775808_i64 {
879                None
880            } else {
881                Some(value)
882            }
883        }
884
885        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
886        #[inline]
887        pub fn trailing_time(&self) -> Option<i64> {
888            let value = self.get_buf().get_i64_at(self.offset + 70);
889            if value == -9223372036854775808_i64 {
890                None
891            } else {
892                Some(value)
893            }
894        }
895
896        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
897        #[inline]
898        pub fn iceberg_qty(&self) -> Option<i64> {
899            let value = self.get_buf().get_i64_at(self.offset + 78);
900            if value == -9223372036854775808_i64 {
901                None
902            } else {
903                Some(value)
904            }
905        }
906
907        /// primitive field - 'REQUIRED'
908        #[inline]
909        pub fn time(&self) -> i64 {
910            self.get_buf().get_i64_at(self.offset + 86)
911        }
912
913        /// primitive field - 'REQUIRED'
914        #[inline]
915        pub fn update_time(&self) -> i64 {
916            self.get_buf().get_i64_at(self.offset + 94)
917        }
918
919        /// REQUIRED enum
920        #[inline]
921        pub fn is_working(&self) -> bool_enum::BoolEnum {
922            self.get_buf().get_u8_at(self.offset + 102).into()
923        }
924
925        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
926        #[inline]
927        pub fn working_time(&self) -> Option<i64> {
928            let value = self.get_buf().get_i64_at(self.offset + 103);
929            if value == -9223372036854775808_i64 {
930                None
931            } else {
932                Some(value)
933            }
934        }
935
936        /// primitive field - 'REQUIRED'
937        #[inline]
938        pub fn orig_quote_order_qty(&self) -> i64 {
939            self.get_buf().get_i64_at(self.offset + 111)
940        }
941
942        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
943        #[inline]
944        pub fn strategy_id(&self) -> Option<i64> {
945            let value = self.get_buf().get_i64_at(self.offset + 119);
946            if value == -9223372036854775808_i64 {
947                None
948            } else {
949                Some(value)
950            }
951        }
952
953        /// primitive field - 'OPTIONAL' { null_value: '-2147483648_i32' }
954        #[inline]
955        pub fn strategy_type(&self) -> Option<i32> {
956            let value = self.get_buf().get_i32_at(self.offset + 127);
957            if value == -2147483648_i32 {
958                None
959            } else {
960                Some(value)
961            }
962        }
963
964        /// REQUIRED enum
965        #[inline]
966        pub fn order_capacity(&self) -> order_capacity::OrderCapacity {
967            self.get_buf().get_u8_at(self.offset + 131).into()
968        }
969
970        /// REQUIRED enum
971        #[inline]
972        pub fn working_floor(&self) -> floor::Floor {
973            self.get_buf().get_u8_at(self.offset + 132).into()
974        }
975
976        /// REQUIRED enum
977        #[inline]
978        pub fn self_trade_prevention_mode(
979            &self,
980        ) -> self_trade_prevention_mode::SelfTradePreventionMode {
981            self.get_buf().get_u8_at(self.offset + 133).into()
982        }
983
984        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
985        #[inline]
986        pub fn prevented_match_id(&self) -> Option<i64> {
987            let value = self.get_buf().get_i64_at(self.offset + 134);
988            if value == -9223372036854775808_i64 {
989                None
990            } else {
991                Some(value)
992            }
993        }
994
995        /// primitive field - 'REQUIRED'
996        #[inline]
997        pub fn prevented_quantity(&self) -> i64 {
998            self.get_buf().get_i64_at(self.offset + 142)
999        }
1000
1001        /// REQUIRED enum
1002        #[inline]
1003        pub fn used_sor(&self) -> bool_enum::BoolEnum {
1004            self.get_buf().get_u8_at(self.offset + 150).into()
1005        }
1006
1007        /// REQUIRED enum
1008        #[inline]
1009        pub fn peg_price_type(&self) -> peg_price_type::PegPriceType {
1010            if self.acting_version() < 1 {
1011                return peg_price_type::PegPriceType::default();
1012            }
1013
1014            self.get_buf().get_u8_at(self.offset + 151).into()
1015        }
1016
1017        /// REQUIRED enum
1018        #[inline]
1019        pub fn peg_offset_type(&self) -> peg_offset_type::PegOffsetType {
1020            if self.acting_version() < 1 {
1021                return peg_offset_type::PegOffsetType::default();
1022            }
1023
1024            self.get_buf().get_u8_at(self.offset + 152).into()
1025        }
1026
1027        /// primitive field - 'OPTIONAL' { null_value: '0xff_u8' }
1028        #[inline]
1029        pub fn peg_offset_value(&self) -> Option<u8> {
1030            if self.acting_version() < 1 {
1031                return None;
1032            }
1033
1034            let value = self.get_buf().get_u8_at(self.offset + 153);
1035            if value == 0xff_u8 { None } else { Some(value) }
1036        }
1037
1038        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
1039        #[inline]
1040        pub fn pegged_price(&self) -> Option<i64> {
1041            if self.acting_version() < 1 {
1042                return None;
1043            }
1044
1045            let value = self.get_buf().get_i64_at(self.offset + 154);
1046            if value == -9223372036854775808_i64 {
1047                None
1048            } else {
1049                Some(value)
1050            }
1051        }
1052
1053        /// REQUIRED enum
1054        #[inline]
1055        pub fn expiry_reason(&self) -> expiry_reason::ExpiryReason {
1056            if self.acting_version() < 4 {
1057                return expiry_reason::ExpiryReason::default();
1058            }
1059
1060            self.get_buf().get_u8_at(self.offset + 162).into()
1061        }
1062
1063        /// VAR_DATA DECODER - character encoding: 'UTF-8'
1064        #[inline]
1065        pub fn symbol_decoder(&mut self) -> (usize, usize) {
1066            let offset = self.parent.as_ref().expect("parent missing").get_limit();
1067            let data_length = self.get_buf().get_u8_at(offset) as usize;
1068            self.parent
1069                .as_mut()
1070                .unwrap()
1071                .set_limit(offset + 1 + data_length);
1072            (offset + 1, data_length)
1073        }
1074
1075        #[inline]
1076        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
1077            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
1078            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
1079        }
1080
1081        /// VAR_DATA DECODER - character encoding: 'UTF-8'
1082        #[inline]
1083        pub fn client_order_id_decoder(&mut self) -> (usize, usize) {
1084            let offset = self.parent.as_ref().expect("parent missing").get_limit();
1085            let data_length = self.get_buf().get_u8_at(offset) as usize;
1086            self.parent
1087                .as_mut()
1088                .unwrap()
1089                .set_limit(offset + 1 + data_length);
1090            (offset + 1, data_length)
1091        }
1092
1093        #[inline]
1094        pub fn client_order_id_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
1095            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
1096            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
1097        }
1098    }
1099} // end decoder
nautilus_binance/spot/sbe/generated/orders_response_codec.rs

nautilus_binance/spot/sbe/generated/
orders_response_codec.rs
