nautilus_binance/spot/sbe/generated/
new_order_result_response_codec.rs

1pub use decoder::NewOrderResultResponseDecoder;
2pub use encoder::NewOrderResultResponseEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 154;
8pub const SBE_TEMPLATE_ID: u16 = 301;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct NewOrderResultResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for NewOrderResultResponseEncoder<'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 NewOrderResultResponseEncoder<'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> NewOrderResultResponseEncoder<'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 'transactTime'
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 transact_time(&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 'price'
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 price(&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 'origQty'
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 orig_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 'executedQty'
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 executed_qty(&mut self, value: i64) {
182            let offset = self.offset + 42;
183            self.get_buf_mut().put_i64_at(offset, value);
184        }
185
186        /// primitive field 'cummulativeQuoteQty'
187        /// - min value: -9223372036854775807
188        /// - max value: 9223372036854775807
189        /// - null value: -9223372036854775808_i64
190        /// - characterEncoding: null
191        /// - semanticType: null
192        /// - encodedOffset: 50
193        /// - encodedLength: 8
194        /// - version: 0
195        #[inline]
196        pub fn cummulative_quote_qty(&mut self, value: i64) {
197            let offset = self.offset + 50;
198            self.get_buf_mut().put_i64_at(offset, value);
199        }
200
201        /// REQUIRED enum
202        #[inline]
203        pub fn status(&mut self, value: order_status::OrderStatus) {
204            let offset = self.offset + 58;
205            self.get_buf_mut().put_u8_at(offset, value as u8)
206        }
207
208        /// REQUIRED enum
209        #[inline]
210        pub fn time_in_force(&mut self, value: time_in_force::TimeInForce) {
211            let offset = self.offset + 59;
212            self.get_buf_mut().put_u8_at(offset, value as u8)
213        }
214
215        /// REQUIRED enum
216        #[inline]
217        pub fn order_type(&mut self, value: order_type::OrderType) {
218            let offset = self.offset + 60;
219            self.get_buf_mut().put_u8_at(offset, value as u8)
220        }
221
222        /// REQUIRED enum
223        #[inline]
224        pub fn side(&mut self, value: order_side::OrderSide) {
225            let offset = self.offset + 61;
226            self.get_buf_mut().put_u8_at(offset, value as u8)
227        }
228
229        /// primitive field 'stopPrice'
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 stop_price(&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 'trailingDelta'
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_delta(&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 'trailingTime'
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 trailing_time(&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 'workingTime'
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 working_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 'icebergQty'
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 iceberg_qty(&mut self, value: i64) {
300            let offset = self.offset + 94;
301            self.get_buf_mut().put_i64_at(offset, value);
302        }
303
304        /// primitive field 'strategyId'
305        /// - min value: -9223372036854775807
306        /// - max value: 9223372036854775807
307        /// - null value: -9223372036854775808_i64
308        /// - characterEncoding: null
309        /// - semanticType: null
310        /// - encodedOffset: 102
311        /// - encodedLength: 8
312        /// - version: 0
313        #[inline]
314        pub fn strategy_id(&mut self, value: i64) {
315            let offset = self.offset + 102;
316            self.get_buf_mut().put_i64_at(offset, value);
317        }
318
319        /// primitive field 'strategyType'
320        /// - min value: -2147483647
321        /// - max value: 2147483647
322        /// - null value: -2147483648_i32
323        /// - characterEncoding: null
324        /// - semanticType: null
325        /// - encodedOffset: 110
326        /// - encodedLength: 4
327        /// - version: 0
328        #[inline]
329        pub fn strategy_type(&mut self, value: i32) {
330            let offset = self.offset + 110;
331            self.get_buf_mut().put_i32_at(offset, value);
332        }
333
334        /// REQUIRED enum
335        #[inline]
336        pub fn order_capacity(&mut self, value: order_capacity::OrderCapacity) {
337            let offset = self.offset + 114;
338            self.get_buf_mut().put_u8_at(offset, value as u8)
339        }
340
341        /// REQUIRED enum
342        #[inline]
343        pub fn working_floor(&mut self, value: floor::Floor) {
344            let offset = self.offset + 115;
345            self.get_buf_mut().put_u8_at(offset, value as u8)
346        }
347
348        /// REQUIRED enum
349        #[inline]
350        pub fn self_trade_prevention_mode(
351            &mut self,
352            value: self_trade_prevention_mode::SelfTradePreventionMode,
353        ) {
354            let offset = self.offset + 116;
355            self.get_buf_mut().put_u8_at(offset, value as u8)
356        }
357
358        /// primitive field 'tradeGroupId'
359        /// - min value: -9223372036854775807
360        /// - max value: 9223372036854775807
361        /// - null value: -9223372036854775808_i64
362        /// - characterEncoding: null
363        /// - semanticType: null
364        /// - encodedOffset: 117
365        /// - encodedLength: 8
366        /// - version: 0
367        #[inline]
368        pub fn trade_group_id(&mut self, value: i64) {
369            let offset = self.offset + 117;
370            self.get_buf_mut().put_i64_at(offset, value);
371        }
372
373        /// primitive field 'preventedQuantity'
374        /// - min value: -9223372036854775807
375        /// - max value: 9223372036854775807
376        /// - null value: -9223372036854775808_i64
377        /// - characterEncoding: null
378        /// - semanticType: null
379        /// - encodedOffset: 125
380        /// - encodedLength: 8
381        /// - version: 0
382        #[inline]
383        pub fn prevented_quantity(&mut self, value: i64) {
384            let offset = self.offset + 125;
385            self.get_buf_mut().put_i64_at(offset, value);
386        }
387
388        /// REQUIRED enum
389        #[inline]
390        pub fn used_sor(&mut self, value: bool_enum::BoolEnum) {
391            let offset = self.offset + 133;
392            self.get_buf_mut().put_u8_at(offset, value as u8)
393        }
394
395        /// primitive field 'origQuoteOrderQty'
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 orig_quote_order_qty(&mut self, value: i64) {
406            let offset = self.offset + 134;
407            self.get_buf_mut().put_i64_at(offset, value);
408        }
409
410        /// REQUIRED enum
411        #[inline]
412        pub fn peg_price_type(&mut self, value: peg_price_type::PegPriceType) {
413            let offset = self.offset + 142;
414            self.get_buf_mut().put_u8_at(offset, value as u8)
415        }
416
417        /// REQUIRED enum
418        #[inline]
419        pub fn peg_offset_type(&mut self, value: peg_offset_type::PegOffsetType) {
420            let offset = self.offset + 143;
421            self.get_buf_mut().put_u8_at(offset, value as u8)
422        }
423
424        /// primitive field 'pegOffsetValue'
425        /// - min value: 0
426        /// - max value: 254
427        /// - null value: 0xff_u8
428        /// - characterEncoding: null
429        /// - semanticType: null
430        /// - encodedOffset: 144
431        /// - encodedLength: 1
432        /// - version: 1
433        #[inline]
434        pub fn peg_offset_value(&mut self, value: u8) {
435            let offset = self.offset + 144;
436            self.get_buf_mut().put_u8_at(offset, value);
437        }
438
439        /// primitive field 'peggedPrice'
440        /// - min value: -9223372036854775807
441        /// - max value: 9223372036854775807
442        /// - null value: -9223372036854775808_i64
443        /// - characterEncoding: null
444        /// - semanticType: null
445        /// - encodedOffset: 145
446        /// - encodedLength: 8
447        /// - version: 1
448        #[inline]
449        pub fn pegged_price(&mut self, value: i64) {
450            let offset = self.offset + 145;
451            self.get_buf_mut().put_i64_at(offset, value);
452        }
453
454        /// REQUIRED enum
455        #[inline]
456        pub fn expiry_reason(&mut self, value: expiry_reason::ExpiryReason) {
457            let offset = self.offset + 153;
458            self.get_buf_mut().put_u8_at(offset, value as u8)
459        }
460
461        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
462        #[inline]
463        pub fn symbol(&mut self, value: &str) {
464            let limit = self.get_limit();
465            let data_length = value.len();
466            self.set_limit(limit + 1 + data_length);
467            self.get_buf_mut().put_u8_at(limit, data_length as u8);
468            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
469        }
470
471        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
472        #[inline]
473        pub fn client_order_id(&mut self, value: &str) {
474            let limit = self.get_limit();
475            let data_length = value.len();
476            self.set_limit(limit + 1 + data_length);
477            self.get_buf_mut().put_u8_at(limit, data_length as u8);
478            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
479        }
480    }
481} // end encoder
482
483pub mod decoder {
484    use message_header_codec::*;
485
486    use super::*;
487
488    #[derive(Clone, Copy, Debug, Default)]
489    pub struct NewOrderResultResponseDecoder<'a> {
490        buf: ReadBuf<'a>,
491        initial_offset: usize,
492        offset: usize,
493        limit: usize,
494        pub acting_block_length: u16,
495        pub acting_version: u16,
496    }
497
498    impl ActingVersion for NewOrderResultResponseDecoder<'_> {
499        #[inline]
500        fn acting_version(&self) -> u16 {
501            self.acting_version
502        }
503    }
504
505    impl<'a> Reader<'a> for NewOrderResultResponseDecoder<'a> {
506        #[inline]
507        fn get_buf(&self) -> &ReadBuf<'a> {
508            &self.buf
509        }
510    }
511
512    impl<'a> Decoder<'a> for NewOrderResultResponseDecoder<'a> {
513        #[inline]
514        fn get_limit(&self) -> usize {
515            self.limit
516        }
517
518        #[inline]
519        fn set_limit(&mut self, limit: usize) {
520            self.limit = limit;
521        }
522    }
523
524    impl<'a> NewOrderResultResponseDecoder<'a> {
525        pub fn wrap(
526            mut self,
527            buf: ReadBuf<'a>,
528            offset: usize,
529            acting_block_length: u16,
530            acting_version: u16,
531        ) -> Self {
532            let limit = offset + acting_block_length as usize;
533            self.buf = buf;
534            self.initial_offset = offset;
535            self.offset = offset;
536            self.limit = limit;
537            self.acting_block_length = acting_block_length;
538            self.acting_version = acting_version;
539            self
540        }
541
542        #[inline]
543        pub fn encoded_length(&self) -> usize {
544            self.limit - self.offset
545        }
546
547        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
548            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
549            let acting_block_length = header.block_length();
550            let acting_version = header.version();
551
552            self.wrap(
553                header.parent().unwrap(),
554                offset + message_header_codec::ENCODED_LENGTH,
555                acting_block_length,
556                acting_version,
557            )
558        }
559
560        /// primitive field - 'REQUIRED'
561        #[inline]
562        pub fn price_exponent(&self) -> i8 {
563            self.get_buf().get_i8_at(self.offset)
564        }
565
566        /// primitive field - 'REQUIRED'
567        #[inline]
568        pub fn qty_exponent(&self) -> i8 {
569            self.get_buf().get_i8_at(self.offset + 1)
570        }
571
572        /// primitive field - 'REQUIRED'
573        #[inline]
574        pub fn order_id(&self) -> i64 {
575            self.get_buf().get_i64_at(self.offset + 2)
576        }
577
578        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
579        #[inline]
580        pub fn order_list_id(&self) -> Option<i64> {
581            let value = self.get_buf().get_i64_at(self.offset + 10);
582            if value == -9223372036854775808_i64 {
583                None
584            } else {
585                Some(value)
586            }
587        }
588
589        /// primitive field - 'REQUIRED'
590        #[inline]
591        pub fn transact_time(&self) -> i64 {
592            self.get_buf().get_i64_at(self.offset + 18)
593        }
594
595        /// primitive field - 'REQUIRED'
596        #[inline]
597        pub fn price(&self) -> i64 {
598            self.get_buf().get_i64_at(self.offset + 26)
599        }
600
601        /// primitive field - 'REQUIRED'
602        #[inline]
603        pub fn orig_qty(&self) -> i64 {
604            self.get_buf().get_i64_at(self.offset + 34)
605        }
606
607        /// primitive field - 'REQUIRED'
608        #[inline]
609        pub fn executed_qty(&self) -> i64 {
610            self.get_buf().get_i64_at(self.offset + 42)
611        }
612
613        /// primitive field - 'REQUIRED'
614        #[inline]
615        pub fn cummulative_quote_qty(&self) -> i64 {
616            self.get_buf().get_i64_at(self.offset + 50)
617        }
618
619        /// REQUIRED enum
620        #[inline]
621        pub fn status(&self) -> order_status::OrderStatus {
622            self.get_buf().get_u8_at(self.offset + 58).into()
623        }
624
625        /// REQUIRED enum
626        #[inline]
627        pub fn time_in_force(&self) -> time_in_force::TimeInForce {
628            self.get_buf().get_u8_at(self.offset + 59).into()
629        }
630
631        /// REQUIRED enum
632        #[inline]
633        pub fn order_type(&self) -> order_type::OrderType {
634            self.get_buf().get_u8_at(self.offset + 60).into()
635        }
636
637        /// REQUIRED enum
638        #[inline]
639        pub fn side(&self) -> order_side::OrderSide {
640            self.get_buf().get_u8_at(self.offset + 61).into()
641        }
642
643        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
644        #[inline]
645        pub fn stop_price(&self) -> Option<i64> {
646            let value = self.get_buf().get_i64_at(self.offset + 62);
647            if value == -9223372036854775808_i64 {
648                None
649            } else {
650                Some(value)
651            }
652        }
653
654        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
655        #[inline]
656        pub fn trailing_delta(&self) -> Option<i64> {
657            let value = self.get_buf().get_i64_at(self.offset + 70);
658            if value == -9223372036854775808_i64 {
659                None
660            } else {
661                Some(value)
662            }
663        }
664
665        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
666        #[inline]
667        pub fn trailing_time(&self) -> Option<i64> {
668            let value = self.get_buf().get_i64_at(self.offset + 78);
669            if value == -9223372036854775808_i64 {
670                None
671            } else {
672                Some(value)
673            }
674        }
675
676        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
677        #[inline]
678        pub fn working_time(&self) -> Option<i64> {
679            let value = self.get_buf().get_i64_at(self.offset + 86);
680            if value == -9223372036854775808_i64 {
681                None
682            } else {
683                Some(value)
684            }
685        }
686
687        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
688        #[inline]
689        pub fn iceberg_qty(&self) -> Option<i64> {
690            let value = self.get_buf().get_i64_at(self.offset + 94);
691            if value == -9223372036854775808_i64 {
692                None
693            } else {
694                Some(value)
695            }
696        }
697
698        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
699        #[inline]
700        pub fn strategy_id(&self) -> Option<i64> {
701            let value = self.get_buf().get_i64_at(self.offset + 102);
702            if value == -9223372036854775808_i64 {
703                None
704            } else {
705                Some(value)
706            }
707        }
708
709        /// primitive field - 'OPTIONAL' { null_value: '-2147483648_i32' }
710        #[inline]
711        pub fn strategy_type(&self) -> Option<i32> {
712            let value = self.get_buf().get_i32_at(self.offset + 110);
713            if value == -2147483648_i32 {
714                None
715            } else {
716                Some(value)
717            }
718        }
719
720        /// REQUIRED enum
721        #[inline]
722        pub fn order_capacity(&self) -> order_capacity::OrderCapacity {
723            self.get_buf().get_u8_at(self.offset + 114).into()
724        }
725
726        /// REQUIRED enum
727        #[inline]
728        pub fn working_floor(&self) -> floor::Floor {
729            self.get_buf().get_u8_at(self.offset + 115).into()
730        }
731
732        /// REQUIRED enum
733        #[inline]
734        pub fn self_trade_prevention_mode(
735            &self,
736        ) -> self_trade_prevention_mode::SelfTradePreventionMode {
737            self.get_buf().get_u8_at(self.offset + 116).into()
738        }
739
740        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
741        #[inline]
742        pub fn trade_group_id(&self) -> Option<i64> {
743            let value = self.get_buf().get_i64_at(self.offset + 117);
744            if value == -9223372036854775808_i64 {
745                None
746            } else {
747                Some(value)
748            }
749        }
750
751        /// primitive field - 'REQUIRED'
752        #[inline]
753        pub fn prevented_quantity(&self) -> i64 {
754            self.get_buf().get_i64_at(self.offset + 125)
755        }
756
757        /// REQUIRED enum
758        #[inline]
759        pub fn used_sor(&self) -> bool_enum::BoolEnum {
760            self.get_buf().get_u8_at(self.offset + 133).into()
761        }
762
763        /// primitive field - 'REQUIRED'
764        #[inline]
765        pub fn orig_quote_order_qty(&self) -> i64 {
766            self.get_buf().get_i64_at(self.offset + 134)
767        }
768
769        /// REQUIRED enum
770        #[inline]
771        pub fn peg_price_type(&self) -> peg_price_type::PegPriceType {
772            if self.acting_version() < 1 {
773                return peg_price_type::PegPriceType::default();
774            }
775
776            self.get_buf().get_u8_at(self.offset + 142).into()
777        }
778
779        /// REQUIRED enum
780        #[inline]
781        pub fn peg_offset_type(&self) -> peg_offset_type::PegOffsetType {
782            if self.acting_version() < 1 {
783                return peg_offset_type::PegOffsetType::default();
784            }
785
786            self.get_buf().get_u8_at(self.offset + 143).into()
787        }
788
789        /// primitive field - 'OPTIONAL' { null_value: '0xff_u8' }
790        #[inline]
791        pub fn peg_offset_value(&self) -> Option<u8> {
792            if self.acting_version() < 1 {
793                return None;
794            }
795
796            let value = self.get_buf().get_u8_at(self.offset + 144);
797            if value == 0xff_u8 { None } else { Some(value) }
798        }
799
800        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
801        #[inline]
802        pub fn pegged_price(&self) -> Option<i64> {
803            if self.acting_version() < 1 {
804                return None;
805            }
806
807            let value = self.get_buf().get_i64_at(self.offset + 145);
808            if value == -9223372036854775808_i64 {
809                None
810            } else {
811                Some(value)
812            }
813        }
814
815        /// REQUIRED enum
816        #[inline]
817        pub fn expiry_reason(&self) -> expiry_reason::ExpiryReason {
818            if self.acting_version() < 3 {
819                return expiry_reason::ExpiryReason::default();
820            }
821
822            self.get_buf().get_u8_at(self.offset + 153).into()
823        }
824
825        /// VAR_DATA DECODER - character encoding: 'UTF-8'
826        #[inline]
827        pub fn symbol_decoder(&mut self) -> (usize, usize) {
828            let offset = self.get_limit();
829            let data_length = self.get_buf().get_u8_at(offset) as usize;
830            self.set_limit(offset + 1 + data_length);
831            (offset + 1, data_length)
832        }
833
834        #[inline]
835        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
836            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
837            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
838        }
839
840        /// VAR_DATA DECODER - character encoding: 'UTF-8'
841        #[inline]
842        pub fn client_order_id_decoder(&mut self) -> (usize, usize) {
843            let offset = self.get_limit();
844            let data_length = self.get_buf().get_u8_at(offset) as usize;
845            self.set_limit(offset + 1 + data_length);
846            (offset + 1, data_length)
847        }
848
849        #[inline]
850        pub fn client_order_id_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
851            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
852            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
853        }
854    }
855} // end decoder
nautilus_binance/spot/sbe/generated/new_order_result_response_codec.rs

nautilus_binance/spot/sbe/generated/
new_order_result_response_codec.rs
