nautilus_binance/spot/sbe/generated/
order_response_codec.rs

1pub use decoder::OrderResponseDecoder;
2pub use encoder::OrderResponseEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 163;
8pub const SBE_TEMPLATE_ID: u16 = 304;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct OrderResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for OrderResponseEncoder<'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 OrderResponseEncoder<'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> OrderResponseEncoder<'a> {
43        pub fn wrap(mut self, buf: WriteBuf<'a>, offset: usize) -> Self {
44            let limit = offset + SBE_BLOCK_LENGTH as usize;
45            self.buf = buf;
46            self.initial_offset = offset;
47            self.offset = offset;
48            self.limit = limit;
49            self
50        }
51
52        #[inline]
53        pub fn encoded_length(&self) -> usize {
54            self.limit - self.offset
55        }
56
57        pub fn header(self, offset: usize) -> MessageHeaderEncoder<Self> {
58            let mut header = MessageHeaderEncoder::default().wrap(self, offset);
59            header.block_length(SBE_BLOCK_LENGTH);
60            header.template_id(SBE_TEMPLATE_ID);
61            header.schema_id(SBE_SCHEMA_ID);
62            header.version(SBE_SCHEMA_VERSION);
63            header
64        }
65
66        /// primitive field 'priceExponent'
67        /// - min value: -127
68        /// - max value: 127
69        /// - null value: -128_i8
70        /// - characterEncoding: null
71        /// - semanticType: null
72        /// - encodedOffset: 0
73        /// - encodedLength: 1
74        /// - version: 0
75        #[inline]
76        pub fn price_exponent(&mut self, value: i8) {
77            let offset = self.offset;
78            self.get_buf_mut().put_i8_at(offset, value);
79        }
80
81        /// primitive field 'qtyExponent'
82        /// - min value: -127
83        /// - max value: 127
84        /// - null value: -128_i8
85        /// - characterEncoding: null
86        /// - semanticType: null
87        /// - encodedOffset: 1
88        /// - encodedLength: 1
89        /// - version: 0
90        #[inline]
91        pub fn qty_exponent(&mut self, value: i8) {
92            let offset = self.offset + 1;
93            self.get_buf_mut().put_i8_at(offset, value);
94        }
95
96        /// primitive field 'orderId'
97        /// - min value: -9223372036854775807
98        /// - max value: 9223372036854775807
99        /// - null value: -9223372036854775808_i64
100        /// - characterEncoding: null
101        /// - semanticType: null
102        /// - encodedOffset: 2
103        /// - encodedLength: 8
104        /// - version: 0
105        #[inline]
106        pub fn order_id(&mut self, value: i64) {
107            let offset = self.offset + 2;
108            self.get_buf_mut().put_i64_at(offset, value);
109        }
110
111        /// primitive field 'orderListId'
112        /// - min value: -9223372036854775807
113        /// - max value: 9223372036854775807
114        /// - null value: -9223372036854775808_i64
115        /// - characterEncoding: null
116        /// - semanticType: null
117        /// - encodedOffset: 10
118        /// - encodedLength: 8
119        /// - version: 0
120        #[inline]
121        pub fn order_list_id(&mut self, value: i64) {
122            let offset = self.offset + 10;
123            self.get_buf_mut().put_i64_at(offset, value);
124        }
125
126        /// primitive field 'price'
127        /// - min value: -9223372036854775807
128        /// - max value: 9223372036854775807
129        /// - null value: -9223372036854775808_i64
130        /// - characterEncoding: null
131        /// - semanticType: null
132        /// - encodedOffset: 18
133        /// - encodedLength: 8
134        /// - version: 0
135        #[inline]
136        pub fn price(&mut self, value: i64) {
137            let offset = self.offset + 18;
138            self.get_buf_mut().put_i64_at(offset, value);
139        }
140
141        /// primitive field 'origQty'
142        /// - min value: -9223372036854775807
143        /// - max value: 9223372036854775807
144        /// - null value: -9223372036854775808_i64
145        /// - characterEncoding: null
146        /// - semanticType: null
147        /// - encodedOffset: 26
148        /// - encodedLength: 8
149        /// - version: 0
150        #[inline]
151        pub fn orig_qty(&mut self, value: i64) {
152            let offset = self.offset + 26;
153            self.get_buf_mut().put_i64_at(offset, value);
154        }
155
156        /// primitive field 'executedQty'
157        /// - min value: -9223372036854775807
158        /// - max value: 9223372036854775807
159        /// - null value: -9223372036854775808_i64
160        /// - characterEncoding: null
161        /// - semanticType: null
162        /// - encodedOffset: 34
163        /// - encodedLength: 8
164        /// - version: 0
165        #[inline]
166        pub fn executed_qty(&mut self, value: i64) {
167            let offset = self.offset + 34;
168            self.get_buf_mut().put_i64_at(offset, value);
169        }
170
171        /// primitive field 'cummulativeQuoteQty'
172        /// - min value: -9223372036854775807
173        /// - max value: 9223372036854775807
174        /// - null value: -9223372036854775808_i64
175        /// - characterEncoding: null
176        /// - semanticType: null
177        /// - encodedOffset: 42
178        /// - encodedLength: 8
179        /// - version: 0
180        #[inline]
181        pub fn cummulative_quote_qty(&mut self, value: i64) {
182            let offset = self.offset + 42;
183            self.get_buf_mut().put_i64_at(offset, value);
184        }
185
186        /// REQUIRED enum
187        #[inline]
188        pub fn status(&mut self, value: order_status::OrderStatus) {
189            let offset = self.offset + 50;
190            self.get_buf_mut().put_u8_at(offset, value as u8)
191        }
192
193        /// REQUIRED enum
194        #[inline]
195        pub fn time_in_force(&mut self, value: time_in_force::TimeInForce) {
196            let offset = self.offset + 51;
197            self.get_buf_mut().put_u8_at(offset, value as u8)
198        }
199
200        /// REQUIRED enum
201        #[inline]
202        pub fn order_type(&mut self, value: order_type::OrderType) {
203            let offset = self.offset + 52;
204            self.get_buf_mut().put_u8_at(offset, value as u8)
205        }
206
207        /// REQUIRED enum
208        #[inline]
209        pub fn side(&mut self, value: order_side::OrderSide) {
210            let offset = self.offset + 53;
211            self.get_buf_mut().put_u8_at(offset, value as u8)
212        }
213
214        /// primitive field 'stopPrice'
215        /// - min value: -9223372036854775807
216        /// - max value: 9223372036854775807
217        /// - null value: -9223372036854775808_i64
218        /// - characterEncoding: null
219        /// - semanticType: null
220        /// - encodedOffset: 54
221        /// - encodedLength: 8
222        /// - version: 0
223        #[inline]
224        pub fn stop_price(&mut self, value: i64) {
225            let offset = self.offset + 54;
226            self.get_buf_mut().put_i64_at(offset, value);
227        }
228
229        /// primitive field 'trailingDelta'
230        /// - min value: -9223372036854775807
231        /// - max value: 9223372036854775807
232        /// - null value: -9223372036854775808_i64
233        /// - characterEncoding: null
234        /// - semanticType: null
235        /// - encodedOffset: 62
236        /// - encodedLength: 8
237        /// - version: 0
238        #[inline]
239        pub fn trailing_delta(&mut self, value: i64) {
240            let offset = self.offset + 62;
241            self.get_buf_mut().put_i64_at(offset, value);
242        }
243
244        /// primitive field 'trailingTime'
245        /// - min value: -9223372036854775807
246        /// - max value: 9223372036854775807
247        /// - null value: -9223372036854775808_i64
248        /// - characterEncoding: null
249        /// - semanticType: null
250        /// - encodedOffset: 70
251        /// - encodedLength: 8
252        /// - version: 0
253        #[inline]
254        pub fn trailing_time(&mut self, value: i64) {
255            let offset = self.offset + 70;
256            self.get_buf_mut().put_i64_at(offset, value);
257        }
258
259        /// primitive field 'icebergQty'
260        /// - min value: -9223372036854775807
261        /// - max value: 9223372036854775807
262        /// - null value: -9223372036854775808_i64
263        /// - characterEncoding: null
264        /// - semanticType: null
265        /// - encodedOffset: 78
266        /// - encodedLength: 8
267        /// - version: 0
268        #[inline]
269        pub fn iceberg_qty(&mut self, value: i64) {
270            let offset = self.offset + 78;
271            self.get_buf_mut().put_i64_at(offset, value);
272        }
273
274        /// primitive field 'time'
275        /// - min value: -9223372036854775807
276        /// - max value: 9223372036854775807
277        /// - null value: -9223372036854775808_i64
278        /// - characterEncoding: null
279        /// - semanticType: null
280        /// - encodedOffset: 86
281        /// - encodedLength: 8
282        /// - version: 0
283        #[inline]
284        pub fn time(&mut self, value: i64) {
285            let offset = self.offset + 86;
286            self.get_buf_mut().put_i64_at(offset, value);
287        }
288
289        /// primitive field 'updateTime'
290        /// - min value: -9223372036854775807
291        /// - max value: 9223372036854775807
292        /// - null value: -9223372036854775808_i64
293        /// - characterEncoding: null
294        /// - semanticType: null
295        /// - encodedOffset: 94
296        /// - encodedLength: 8
297        /// - version: 0
298        #[inline]
299        pub fn update_time(&mut self, value: i64) {
300            let offset = self.offset + 94;
301            self.get_buf_mut().put_i64_at(offset, value);
302        }
303
304        /// REQUIRED enum
305        #[inline]
306        pub fn is_working(&mut self, value: bool_enum::BoolEnum) {
307            let offset = self.offset + 102;
308            self.get_buf_mut().put_u8_at(offset, value as u8)
309        }
310
311        /// primitive field 'workingTime'
312        /// - min value: -9223372036854775807
313        /// - max value: 9223372036854775807
314        /// - null value: -9223372036854775808_i64
315        /// - characterEncoding: null
316        /// - semanticType: null
317        /// - encodedOffset: 103
318        /// - encodedLength: 8
319        /// - version: 0
320        #[inline]
321        pub fn working_time(&mut self, value: i64) {
322            let offset = self.offset + 103;
323            self.get_buf_mut().put_i64_at(offset, value);
324        }
325
326        /// primitive field 'origQuoteOrderQty'
327        /// - min value: -9223372036854775807
328        /// - max value: 9223372036854775807
329        /// - null value: -9223372036854775808_i64
330        /// - characterEncoding: null
331        /// - semanticType: null
332        /// - encodedOffset: 111
333        /// - encodedLength: 8
334        /// - version: 0
335        #[inline]
336        pub fn orig_quote_order_qty(&mut self, value: i64) {
337            let offset = self.offset + 111;
338            self.get_buf_mut().put_i64_at(offset, value);
339        }
340
341        /// primitive field 'strategyId'
342        /// - min value: -9223372036854775807
343        /// - max value: 9223372036854775807
344        /// - null value: -9223372036854775808_i64
345        /// - characterEncoding: null
346        /// - semanticType: null
347        /// - encodedOffset: 119
348        /// - encodedLength: 8
349        /// - version: 0
350        #[inline]
351        pub fn strategy_id(&mut self, value: i64) {
352            let offset = self.offset + 119;
353            self.get_buf_mut().put_i64_at(offset, value);
354        }
355
356        /// primitive field 'strategyType'
357        /// - min value: -2147483647
358        /// - max value: 2147483647
359        /// - null value: -2147483648_i32
360        /// - characterEncoding: null
361        /// - semanticType: null
362        /// - encodedOffset: 127
363        /// - encodedLength: 4
364        /// - version: 0
365        #[inline]
366        pub fn strategy_type(&mut self, value: i32) {
367            let offset = self.offset + 127;
368            self.get_buf_mut().put_i32_at(offset, value);
369        }
370
371        /// REQUIRED enum
372        #[inline]
373        pub fn order_capacity(&mut self, value: order_capacity::OrderCapacity) {
374            let offset = self.offset + 131;
375            self.get_buf_mut().put_u8_at(offset, value as u8)
376        }
377
378        /// REQUIRED enum
379        #[inline]
380        pub fn working_floor(&mut self, value: floor::Floor) {
381            let offset = self.offset + 132;
382            self.get_buf_mut().put_u8_at(offset, value as u8)
383        }
384
385        /// REQUIRED enum
386        #[inline]
387        pub fn self_trade_prevention_mode(
388            &mut self,
389            value: self_trade_prevention_mode::SelfTradePreventionMode,
390        ) {
391            let offset = self.offset + 133;
392            self.get_buf_mut().put_u8_at(offset, value as u8)
393        }
394
395        /// primitive field 'preventedMatchId'
396        /// - min value: -9223372036854775807
397        /// - max value: 9223372036854775807
398        /// - null value: -9223372036854775808_i64
399        /// - characterEncoding: null
400        /// - semanticType: null
401        /// - encodedOffset: 134
402        /// - encodedLength: 8
403        /// - version: 0
404        #[inline]
405        pub fn prevented_match_id(&mut self, value: i64) {
406            let offset = self.offset + 134;
407            self.get_buf_mut().put_i64_at(offset, value);
408        }
409
410        /// primitive field 'preventedQuantity'
411        /// - min value: -9223372036854775807
412        /// - max value: 9223372036854775807
413        /// - null value: -9223372036854775808_i64
414        /// - characterEncoding: null
415        /// - semanticType: null
416        /// - encodedOffset: 142
417        /// - encodedLength: 8
418        /// - version: 0
419        #[inline]
420        pub fn prevented_quantity(&mut self, value: i64) {
421            let offset = self.offset + 142;
422            self.get_buf_mut().put_i64_at(offset, value);
423        }
424
425        /// REQUIRED enum
426        #[inline]
427        pub fn used_sor(&mut self, value: bool_enum::BoolEnum) {
428            let offset = self.offset + 150;
429            self.get_buf_mut().put_u8_at(offset, value as u8)
430        }
431
432        /// REQUIRED enum
433        #[inline]
434        pub fn peg_price_type(&mut self, value: peg_price_type::PegPriceType) {
435            let offset = self.offset + 151;
436            self.get_buf_mut().put_u8_at(offset, value as u8)
437        }
438
439        /// REQUIRED enum
440        #[inline]
441        pub fn peg_offset_type(&mut self, value: peg_offset_type::PegOffsetType) {
442            let offset = self.offset + 152;
443            self.get_buf_mut().put_u8_at(offset, value as u8)
444        }
445
446        /// primitive field 'pegOffsetValue'
447        /// - min value: 0
448        /// - max value: 254
449        /// - null value: 0xff_u8
450        /// - characterEncoding: null
451        /// - semanticType: null
452        /// - encodedOffset: 153
453        /// - encodedLength: 1
454        /// - version: 1
455        #[inline]
456        pub fn peg_offset_value(&mut self, value: u8) {
457            let offset = self.offset + 153;
458            self.get_buf_mut().put_u8_at(offset, value);
459        }
460
461        /// primitive field 'peggedPrice'
462        /// - min value: -9223372036854775807
463        /// - max value: 9223372036854775807
464        /// - null value: -9223372036854775808_i64
465        /// - characterEncoding: null
466        /// - semanticType: null
467        /// - encodedOffset: 154
468        /// - encodedLength: 8
469        /// - version: 1
470        #[inline]
471        pub fn pegged_price(&mut self, value: i64) {
472            let offset = self.offset + 154;
473            self.get_buf_mut().put_i64_at(offset, value);
474        }
475
476        /// REQUIRED enum
477        #[inline]
478        pub fn expiry_reason(&mut self, value: expiry_reason::ExpiryReason) {
479            let offset = self.offset + 162;
480            self.get_buf_mut().put_u8_at(offset, value as u8)
481        }
482
483        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
484        #[inline]
485        pub fn symbol(&mut self, value: &str) {
486            let limit = self.get_limit();
487            let data_length = value.len();
488            self.set_limit(limit + 1 + data_length);
489            self.get_buf_mut().put_u8_at(limit, data_length as u8);
490            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
491        }
492
493        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
494        #[inline]
495        pub fn client_order_id(&mut self, value: &str) {
496            let limit = self.get_limit();
497            let data_length = value.len();
498            self.set_limit(limit + 1 + data_length);
499            self.get_buf_mut().put_u8_at(limit, data_length as u8);
500            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
501        }
502    }
503} // end encoder
504
505pub mod decoder {
506    use message_header_codec::*;
507
508    use super::*;
509
510    #[derive(Clone, Copy, Debug, Default)]
511    pub struct OrderResponseDecoder<'a> {
512        buf: ReadBuf<'a>,
513        initial_offset: usize,
514        offset: usize,
515        limit: usize,
516        pub acting_block_length: u16,
517        pub acting_version: u16,
518    }
519
520    impl ActingVersion for OrderResponseDecoder<'_> {
521        #[inline]
522        fn acting_version(&self) -> u16 {
523            self.acting_version
524        }
525    }
526
527    impl<'a> Reader<'a> for OrderResponseDecoder<'a> {
528        #[inline]
529        fn get_buf(&self) -> &ReadBuf<'a> {
530            &self.buf
531        }
532    }
533
534    impl<'a> Decoder<'a> for OrderResponseDecoder<'a> {
535        #[inline]
536        fn get_limit(&self) -> usize {
537            self.limit
538        }
539
540        #[inline]
541        fn set_limit(&mut self, limit: usize) {
542            self.limit = limit;
543        }
544    }
545
546    impl<'a> OrderResponseDecoder<'a> {
547        pub fn wrap(
548            mut self,
549            buf: ReadBuf<'a>,
550            offset: usize,
551            acting_block_length: u16,
552            acting_version: u16,
553        ) -> Self {
554            let limit = offset + acting_block_length as usize;
555            self.buf = buf;
556            self.initial_offset = offset;
557            self.offset = offset;
558            self.limit = limit;
559            self.acting_block_length = acting_block_length;
560            self.acting_version = acting_version;
561            self
562        }
563
564        #[inline]
565        pub fn encoded_length(&self) -> usize {
566            self.limit - self.offset
567        }
568
569        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
570            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
571            let acting_block_length = header.block_length();
572            let acting_version = header.version();
573
574            self.wrap(
575                header.parent().unwrap(),
576                offset + message_header_codec::ENCODED_LENGTH,
577                acting_block_length,
578                acting_version,
579            )
580        }
581
582        /// primitive field - 'REQUIRED'
583        #[inline]
584        pub fn price_exponent(&self) -> i8 {
585            self.get_buf().get_i8_at(self.offset)
586        }
587
588        /// primitive field - 'REQUIRED'
589        #[inline]
590        pub fn qty_exponent(&self) -> i8 {
591            self.get_buf().get_i8_at(self.offset + 1)
592        }
593
594        /// primitive field - 'REQUIRED'
595        #[inline]
596        pub fn order_id(&self) -> i64 {
597            self.get_buf().get_i64_at(self.offset + 2)
598        }
599
600        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
601        #[inline]
602        pub fn order_list_id(&self) -> Option<i64> {
603            let value = self.get_buf().get_i64_at(self.offset + 10);
604            if value == -9223372036854775808_i64 {
605                None
606            } else {
607                Some(value)
608            }
609        }
610
611        /// primitive field - 'REQUIRED'
612        #[inline]
613        pub fn price(&self) -> i64 {
614            self.get_buf().get_i64_at(self.offset + 18)
615        }
616
617        /// primitive field - 'REQUIRED'
618        #[inline]
619        pub fn orig_qty(&self) -> i64 {
620            self.get_buf().get_i64_at(self.offset + 26)
621        }
622
623        /// primitive field - 'REQUIRED'
624        #[inline]
625        pub fn executed_qty(&self) -> i64 {
626            self.get_buf().get_i64_at(self.offset + 34)
627        }
628
629        /// primitive field - 'REQUIRED'
630        #[inline]
631        pub fn cummulative_quote_qty(&self) -> i64 {
632            self.get_buf().get_i64_at(self.offset + 42)
633        }
634
635        /// REQUIRED enum
636        #[inline]
637        pub fn status(&self) -> order_status::OrderStatus {
638            self.get_buf().get_u8_at(self.offset + 50).into()
639        }
640
641        /// REQUIRED enum
642        #[inline]
643        pub fn time_in_force(&self) -> time_in_force::TimeInForce {
644            self.get_buf().get_u8_at(self.offset + 51).into()
645        }
646
647        /// REQUIRED enum
648        #[inline]
649        pub fn order_type(&self) -> order_type::OrderType {
650            self.get_buf().get_u8_at(self.offset + 52).into()
651        }
652
653        /// REQUIRED enum
654        #[inline]
655        pub fn side(&self) -> order_side::OrderSide {
656            self.get_buf().get_u8_at(self.offset + 53).into()
657        }
658
659        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
660        #[inline]
661        pub fn stop_price(&self) -> Option<i64> {
662            let value = self.get_buf().get_i64_at(self.offset + 54);
663            if value == -9223372036854775808_i64 {
664                None
665            } else {
666                Some(value)
667            }
668        }
669
670        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
671        #[inline]
672        pub fn trailing_delta(&self) -> Option<i64> {
673            let value = self.get_buf().get_i64_at(self.offset + 62);
674            if value == -9223372036854775808_i64 {
675                None
676            } else {
677                Some(value)
678            }
679        }
680
681        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
682        #[inline]
683        pub fn trailing_time(&self) -> Option<i64> {
684            let value = self.get_buf().get_i64_at(self.offset + 70);
685            if value == -9223372036854775808_i64 {
686                None
687            } else {
688                Some(value)
689            }
690        }
691
692        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
693        #[inline]
694        pub fn iceberg_qty(&self) -> Option<i64> {
695            let value = self.get_buf().get_i64_at(self.offset + 78);
696            if value == -9223372036854775808_i64 {
697                None
698            } else {
699                Some(value)
700            }
701        }
702
703        /// primitive field - 'REQUIRED'
704        #[inline]
705        pub fn time(&self) -> i64 {
706            self.get_buf().get_i64_at(self.offset + 86)
707        }
708
709        /// primitive field - 'REQUIRED'
710        #[inline]
711        pub fn update_time(&self) -> i64 {
712            self.get_buf().get_i64_at(self.offset + 94)
713        }
714
715        /// REQUIRED enum
716        #[inline]
717        pub fn is_working(&self) -> bool_enum::BoolEnum {
718            self.get_buf().get_u8_at(self.offset + 102).into()
719        }
720
721        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
722        #[inline]
723        pub fn working_time(&self) -> Option<i64> {
724            let value = self.get_buf().get_i64_at(self.offset + 103);
725            if value == -9223372036854775808_i64 {
726                None
727            } else {
728                Some(value)
729            }
730        }
731
732        /// primitive field - 'REQUIRED'
733        #[inline]
734        pub fn orig_quote_order_qty(&self) -> i64 {
735            self.get_buf().get_i64_at(self.offset + 111)
736        }
737
738        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
739        #[inline]
740        pub fn strategy_id(&self) -> Option<i64> {
741            let value = self.get_buf().get_i64_at(self.offset + 119);
742            if value == -9223372036854775808_i64 {
743                None
744            } else {
745                Some(value)
746            }
747        }
748
749        /// primitive field - 'OPTIONAL' { null_value: '-2147483648_i32' }
750        #[inline]
751        pub fn strategy_type(&self) -> Option<i32> {
752            let value = self.get_buf().get_i32_at(self.offset + 127);
753            if value == -2147483648_i32 {
754                None
755            } else {
756                Some(value)
757            }
758        }
759
760        /// REQUIRED enum
761        #[inline]
762        pub fn order_capacity(&self) -> order_capacity::OrderCapacity {
763            self.get_buf().get_u8_at(self.offset + 131).into()
764        }
765
766        /// REQUIRED enum
767        #[inline]
768        pub fn working_floor(&self) -> floor::Floor {
769            self.get_buf().get_u8_at(self.offset + 132).into()
770        }
771
772        /// REQUIRED enum
773        #[inline]
774        pub fn self_trade_prevention_mode(
775            &self,
776        ) -> self_trade_prevention_mode::SelfTradePreventionMode {
777            self.get_buf().get_u8_at(self.offset + 133).into()
778        }
779
780        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
781        #[inline]
782        pub fn prevented_match_id(&self) -> Option<i64> {
783            let value = self.get_buf().get_i64_at(self.offset + 134);
784            if value == -9223372036854775808_i64 {
785                None
786            } else {
787                Some(value)
788            }
789        }
790
791        /// primitive field - 'REQUIRED'
792        #[inline]
793        pub fn prevented_quantity(&self) -> i64 {
794            self.get_buf().get_i64_at(self.offset + 142)
795        }
796
797        /// REQUIRED enum
798        #[inline]
799        pub fn used_sor(&self) -> bool_enum::BoolEnum {
800            self.get_buf().get_u8_at(self.offset + 150).into()
801        }
802
803        /// REQUIRED enum
804        #[inline]
805        pub fn peg_price_type(&self) -> peg_price_type::PegPriceType {
806            if self.acting_version() < 1 {
807                return peg_price_type::PegPriceType::default();
808            }
809
810            self.get_buf().get_u8_at(self.offset + 151).into()
811        }
812
813        /// REQUIRED enum
814        #[inline]
815        pub fn peg_offset_type(&self) -> peg_offset_type::PegOffsetType {
816            if self.acting_version() < 1 {
817                return peg_offset_type::PegOffsetType::default();
818            }
819
820            self.get_buf().get_u8_at(self.offset + 152).into()
821        }
822
823        /// primitive field - 'OPTIONAL' { null_value: '0xff_u8' }
824        #[inline]
825        pub fn peg_offset_value(&self) -> Option<u8> {
826            if self.acting_version() < 1 {
827                return None;
828            }
829
830            let value = self.get_buf().get_u8_at(self.offset + 153);
831            if value == 0xff_u8 { None } else { Some(value) }
832        }
833
834        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
835        #[inline]
836        pub fn pegged_price(&self) -> Option<i64> {
837            if self.acting_version() < 1 {
838                return None;
839            }
840
841            let value = self.get_buf().get_i64_at(self.offset + 154);
842            if value == -9223372036854775808_i64 {
843                None
844            } else {
845                Some(value)
846            }
847        }
848
849        /// REQUIRED enum
850        #[inline]
851        pub fn expiry_reason(&self) -> expiry_reason::ExpiryReason {
852            if self.acting_version() < 4 {
853                return expiry_reason::ExpiryReason::default();
854            }
855
856            self.get_buf().get_u8_at(self.offset + 162).into()
857        }
858
859        /// VAR_DATA DECODER - character encoding: 'UTF-8'
860        #[inline]
861        pub fn symbol_decoder(&mut self) -> (usize, usize) {
862            let offset = self.get_limit();
863            let data_length = self.get_buf().get_u8_at(offset) as usize;
864            self.set_limit(offset + 1 + data_length);
865            (offset + 1, data_length)
866        }
867
868        #[inline]
869        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
870            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
871            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
872        }
873
874        /// VAR_DATA DECODER - character encoding: 'UTF-8'
875        #[inline]
876        pub fn client_order_id_decoder(&mut self) -> (usize, usize) {
877            let offset = self.get_limit();
878            let data_length = self.get_buf().get_u8_at(offset) as usize;
879            self.set_limit(offset + 1 + data_length);
880            (offset + 1, data_length)
881        }
882
883        #[inline]
884        pub fn client_order_id_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
885            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
886            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
887        }
888    }
889} // end decoder
nautilus_binance/spot/sbe/generated/order_response_codec.rs

nautilus_binance/spot/sbe/generated/
order_response_codec.rs
