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 = 162;
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        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
477        #[inline]
478        pub fn symbol(&mut self, value: &str) {
479            let limit = self.get_limit();
480            let data_length = value.len();
481            self.set_limit(limit + 1 + data_length);
482            self.get_buf_mut().put_u8_at(limit, data_length as u8);
483            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
484        }
485
486        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
487        #[inline]
488        pub fn client_order_id(&mut self, value: &str) {
489            let limit = self.get_limit();
490            let data_length = value.len();
491            self.set_limit(limit + 1 + data_length);
492            self.get_buf_mut().put_u8_at(limit, data_length as u8);
493            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
494        }
495    }
496} // end encoder
497
498pub mod decoder {
499    use message_header_codec::*;
500
501    use super::*;
502
503    #[derive(Clone, Copy, Debug, Default)]
504    pub struct OrderResponseDecoder<'a> {
505        buf: ReadBuf<'a>,
506        initial_offset: usize,
507        offset: usize,
508        limit: usize,
509        pub acting_block_length: u16,
510        pub acting_version: u16,
511    }
512
513    impl ActingVersion for OrderResponseDecoder<'_> {
514        #[inline]
515        fn acting_version(&self) -> u16 {
516            self.acting_version
517        }
518    }
519
520    impl<'a> Reader<'a> for OrderResponseDecoder<'a> {
521        #[inline]
522        fn get_buf(&self) -> &ReadBuf<'a> {
523            &self.buf
524        }
525    }
526
527    impl<'a> Decoder<'a> for OrderResponseDecoder<'a> {
528        #[inline]
529        fn get_limit(&self) -> usize {
530            self.limit
531        }
532
533        #[inline]
534        fn set_limit(&mut self, limit: usize) {
535            self.limit = limit;
536        }
537    }
538
539    impl<'a> OrderResponseDecoder<'a> {
540        pub fn wrap(
541            mut self,
542            buf: ReadBuf<'a>,
543            offset: usize,
544            acting_block_length: u16,
545            acting_version: u16,
546        ) -> Self {
547            let limit = offset + acting_block_length as usize;
548            self.buf = buf;
549            self.initial_offset = offset;
550            self.offset = offset;
551            self.limit = limit;
552            self.acting_block_length = acting_block_length;
553            self.acting_version = acting_version;
554            self
555        }
556
557        #[inline]
558        pub fn encoded_length(&self) -> usize {
559            self.limit - self.offset
560        }
561
562        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
563            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
564            let acting_block_length = header.block_length();
565            let acting_version = header.version();
566
567            self.wrap(
568                header.parent().unwrap(),
569                offset + message_header_codec::ENCODED_LENGTH,
570                acting_block_length,
571                acting_version,
572            )
573        }
574
575        /// primitive field - 'REQUIRED'
576        #[inline]
577        pub fn price_exponent(&self) -> i8 {
578            self.get_buf().get_i8_at(self.offset)
579        }
580
581        /// primitive field - 'REQUIRED'
582        #[inline]
583        pub fn qty_exponent(&self) -> i8 {
584            self.get_buf().get_i8_at(self.offset + 1)
585        }
586
587        /// primitive field - 'REQUIRED'
588        #[inline]
589        pub fn order_id(&self) -> i64 {
590            self.get_buf().get_i64_at(self.offset + 2)
591        }
592
593        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
594        #[inline]
595        pub fn order_list_id(&self) -> Option<i64> {
596            let value = self.get_buf().get_i64_at(self.offset + 10);
597            if value == -9223372036854775808_i64 {
598                None
599            } else {
600                Some(value)
601            }
602        }
603
604        /// primitive field - 'REQUIRED'
605        #[inline]
606        pub fn price(&self) -> i64 {
607            self.get_buf().get_i64_at(self.offset + 18)
608        }
609
610        /// primitive field - 'REQUIRED'
611        #[inline]
612        pub fn orig_qty(&self) -> i64 {
613            self.get_buf().get_i64_at(self.offset + 26)
614        }
615
616        /// primitive field - 'REQUIRED'
617        #[inline]
618        pub fn executed_qty(&self) -> i64 {
619            self.get_buf().get_i64_at(self.offset + 34)
620        }
621
622        /// primitive field - 'REQUIRED'
623        #[inline]
624        pub fn cummulative_quote_qty(&self) -> i64 {
625            self.get_buf().get_i64_at(self.offset + 42)
626        }
627
628        /// REQUIRED enum
629        #[inline]
630        pub fn status(&self) -> order_status::OrderStatus {
631            self.get_buf().get_u8_at(self.offset + 50).into()
632        }
633
634        /// REQUIRED enum
635        #[inline]
636        pub fn time_in_force(&self) -> time_in_force::TimeInForce {
637            self.get_buf().get_u8_at(self.offset + 51).into()
638        }
639
640        /// REQUIRED enum
641        #[inline]
642        pub fn order_type(&self) -> order_type::OrderType {
643            self.get_buf().get_u8_at(self.offset + 52).into()
644        }
645
646        /// REQUIRED enum
647        #[inline]
648        pub fn side(&self) -> order_side::OrderSide {
649            self.get_buf().get_u8_at(self.offset + 53).into()
650        }
651
652        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
653        #[inline]
654        pub fn stop_price(&self) -> Option<i64> {
655            let value = self.get_buf().get_i64_at(self.offset + 54);
656            if value == -9223372036854775808_i64 {
657                None
658            } else {
659                Some(value)
660            }
661        }
662
663        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
664        #[inline]
665        pub fn trailing_delta(&self) -> Option<i64> {
666            let value = self.get_buf().get_i64_at(self.offset + 62);
667            if value == -9223372036854775808_i64 {
668                None
669            } else {
670                Some(value)
671            }
672        }
673
674        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
675        #[inline]
676        pub fn trailing_time(&self) -> Option<i64> {
677            let value = self.get_buf().get_i64_at(self.offset + 70);
678            if value == -9223372036854775808_i64 {
679                None
680            } else {
681                Some(value)
682            }
683        }
684
685        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
686        #[inline]
687        pub fn iceberg_qty(&self) -> Option<i64> {
688            let value = self.get_buf().get_i64_at(self.offset + 78);
689            if value == -9223372036854775808_i64 {
690                None
691            } else {
692                Some(value)
693            }
694        }
695
696        /// primitive field - 'REQUIRED'
697        #[inline]
698        pub fn time(&self) -> i64 {
699            self.get_buf().get_i64_at(self.offset + 86)
700        }
701
702        /// primitive field - 'REQUIRED'
703        #[inline]
704        pub fn update_time(&self) -> i64 {
705            self.get_buf().get_i64_at(self.offset + 94)
706        }
707
708        /// REQUIRED enum
709        #[inline]
710        pub fn is_working(&self) -> bool_enum::BoolEnum {
711            self.get_buf().get_u8_at(self.offset + 102).into()
712        }
713
714        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
715        #[inline]
716        pub fn working_time(&self) -> Option<i64> {
717            let value = self.get_buf().get_i64_at(self.offset + 103);
718            if value == -9223372036854775808_i64 {
719                None
720            } else {
721                Some(value)
722            }
723        }
724
725        /// primitive field - 'REQUIRED'
726        #[inline]
727        pub fn orig_quote_order_qty(&self) -> i64 {
728            self.get_buf().get_i64_at(self.offset + 111)
729        }
730
731        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
732        #[inline]
733        pub fn strategy_id(&self) -> Option<i64> {
734            let value = self.get_buf().get_i64_at(self.offset + 119);
735            if value == -9223372036854775808_i64 {
736                None
737            } else {
738                Some(value)
739            }
740        }
741
742        /// primitive field - 'OPTIONAL' { null_value: '-2147483648_i32' }
743        #[inline]
744        pub fn strategy_type(&self) -> Option<i32> {
745            let value = self.get_buf().get_i32_at(self.offset + 127);
746            if value == -2147483648_i32 {
747                None
748            } else {
749                Some(value)
750            }
751        }
752
753        /// REQUIRED enum
754        #[inline]
755        pub fn order_capacity(&self) -> order_capacity::OrderCapacity {
756            self.get_buf().get_u8_at(self.offset + 131).into()
757        }
758
759        /// REQUIRED enum
760        #[inline]
761        pub fn working_floor(&self) -> floor::Floor {
762            self.get_buf().get_u8_at(self.offset + 132).into()
763        }
764
765        /// REQUIRED enum
766        #[inline]
767        pub fn self_trade_prevention_mode(
768            &self,
769        ) -> self_trade_prevention_mode::SelfTradePreventionMode {
770            self.get_buf().get_u8_at(self.offset + 133).into()
771        }
772
773        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
774        #[inline]
775        pub fn prevented_match_id(&self) -> Option<i64> {
776            let value = self.get_buf().get_i64_at(self.offset + 134);
777            if value == -9223372036854775808_i64 {
778                None
779            } else {
780                Some(value)
781            }
782        }
783
784        /// primitive field - 'REQUIRED'
785        #[inline]
786        pub fn prevented_quantity(&self) -> i64 {
787            self.get_buf().get_i64_at(self.offset + 142)
788        }
789
790        /// REQUIRED enum
791        #[inline]
792        pub fn used_sor(&self) -> bool_enum::BoolEnum {
793            self.get_buf().get_u8_at(self.offset + 150).into()
794        }
795
796        /// REQUIRED enum
797        #[inline]
798        pub fn peg_price_type(&self) -> peg_price_type::PegPriceType {
799            if self.acting_version() < 1 {
800                return peg_price_type::PegPriceType::default();
801            }
802
803            self.get_buf().get_u8_at(self.offset + 151).into()
804        }
805
806        /// REQUIRED enum
807        #[inline]
808        pub fn peg_offset_type(&self) -> peg_offset_type::PegOffsetType {
809            if self.acting_version() < 1 {
810                return peg_offset_type::PegOffsetType::default();
811            }
812
813            self.get_buf().get_u8_at(self.offset + 152).into()
814        }
815
816        /// primitive field - 'OPTIONAL' { null_value: '0xff_u8' }
817        #[inline]
818        pub fn peg_offset_value(&self) -> Option<u8> {
819            if self.acting_version() < 1 {
820                return None;
821            }
822
823            let value = self.get_buf().get_u8_at(self.offset + 153);
824            if value == 0xff_u8 { None } else { Some(value) }
825        }
826
827        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
828        #[inline]
829        pub fn pegged_price(&self) -> Option<i64> {
830            if self.acting_version() < 1 {
831                return None;
832            }
833
834            let value = self.get_buf().get_i64_at(self.offset + 154);
835            if value == -9223372036854775808_i64 {
836                None
837            } else {
838                Some(value)
839            }
840        }
841
842        /// VAR_DATA DECODER - character encoding: 'UTF-8'
843        #[inline]
844        pub fn symbol_decoder(&mut self) -> (usize, usize) {
845            let offset = self.get_limit();
846            let data_length = self.get_buf().get_u8_at(offset) as usize;
847            self.set_limit(offset + 1 + data_length);
848            (offset + 1, data_length)
849        }
850
851        #[inline]
852        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
853            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
854            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
855        }
856
857        /// VAR_DATA DECODER - character encoding: 'UTF-8'
858        #[inline]
859        pub fn client_order_id_decoder(&mut self) -> (usize, usize) {
860            let offset = self.get_limit();
861            let data_length = self.get_buf().get_u8_at(offset) as usize;
862            self.set_limit(offset + 1 + data_length);
863            (offset + 1, data_length)
864        }
865
866        #[inline]
867        pub fn client_order_id_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
868            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
869            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
870        }
871    }
872} // end decoder
nautilus_binance/spot/sbe/generated/order_response_codec.rs

nautilus_binance/spot/sbe/generated/
order_response_codec.rs
