nautilus_binance/spot/sbe/generated/
price_range_execution_rule_codec.rs

1pub use decoder::PriceRangeExecutionRuleDecoder;
2pub use encoder::PriceRangeExecutionRuleEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 33;
8pub const SBE_TEMPLATE_ID: u16 = 22;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct PriceRangeExecutionRuleEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for PriceRangeExecutionRuleEncoder<'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 PriceRangeExecutionRuleEncoder<'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> PriceRangeExecutionRuleEncoder<'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        // skipping CONSTANT enum 'ruleType'
67
68        /// primitive field 'multiplierExponent'
69        /// - min value: -127
70        /// - max value: 127
71        /// - null value: -128_i8
72        /// - characterEncoding: null
73        /// - semanticType: null
74        /// - encodedOffset: 0
75        /// - encodedLength: 1
76        /// - version: 0
77        #[inline]
78        pub fn multiplier_exponent(&mut self, value: i8) {
79            let offset = self.offset;
80            self.get_buf_mut().put_i8_at(offset, value);
81        }
82
83        /// primitive field 'bidLimitMultUp'
84        /// - min value: -9223372036854775807
85        /// - max value: 9223372036854775807
86        /// - null value: -9223372036854775808_i64
87        /// - characterEncoding: null
88        /// - semanticType: null
89        /// - encodedOffset: 1
90        /// - encodedLength: 8
91        /// - version: 0
92        #[inline]
93        pub fn bid_limit_mult_up(&mut self, value: i64) {
94            let offset = self.offset + 1;
95            self.get_buf_mut().put_i64_at(offset, value);
96        }
97
98        /// primitive field 'bidLimitMultDown'
99        /// - min value: -9223372036854775807
100        /// - max value: 9223372036854775807
101        /// - null value: -9223372036854775808_i64
102        /// - characterEncoding: null
103        /// - semanticType: null
104        /// - encodedOffset: 9
105        /// - encodedLength: 8
106        /// - version: 0
107        #[inline]
108        pub fn bid_limit_mult_down(&mut self, value: i64) {
109            let offset = self.offset + 9;
110            self.get_buf_mut().put_i64_at(offset, value);
111        }
112
113        /// primitive field 'askLimitMultUp'
114        /// - min value: -9223372036854775807
115        /// - max value: 9223372036854775807
116        /// - null value: -9223372036854775808_i64
117        /// - characterEncoding: null
118        /// - semanticType: null
119        /// - encodedOffset: 17
120        /// - encodedLength: 8
121        /// - version: 0
122        #[inline]
123        pub fn ask_limit_mult_up(&mut self, value: i64) {
124            let offset = self.offset + 17;
125            self.get_buf_mut().put_i64_at(offset, value);
126        }
127
128        /// primitive field 'askLimitMultDown'
129        /// - min value: -9223372036854775807
130        /// - max value: 9223372036854775807
131        /// - null value: -9223372036854775808_i64
132        /// - characterEncoding: null
133        /// - semanticType: null
134        /// - encodedOffset: 25
135        /// - encodedLength: 8
136        /// - version: 0
137        #[inline]
138        pub fn ask_limit_mult_down(&mut self, value: i64) {
139            let offset = self.offset + 25;
140            self.get_buf_mut().put_i64_at(offset, value);
141        }
142    }
143} // end encoder
144
145pub mod decoder {
146    use message_header_codec::*;
147
148    use super::*;
149
150    #[derive(Clone, Copy, Debug, Default)]
151    pub struct PriceRangeExecutionRuleDecoder<'a> {
152        buf: ReadBuf<'a>,
153        initial_offset: usize,
154        offset: usize,
155        limit: usize,
156        pub acting_block_length: u16,
157        pub acting_version: u16,
158    }
159
160    impl ActingVersion for PriceRangeExecutionRuleDecoder<'_> {
161        #[inline]
162        fn acting_version(&self) -> u16 {
163            self.acting_version
164        }
165    }
166
167    impl<'a> Reader<'a> for PriceRangeExecutionRuleDecoder<'a> {
168        #[inline]
169        fn get_buf(&self) -> &ReadBuf<'a> {
170            &self.buf
171        }
172    }
173
174    impl<'a> Decoder<'a> for PriceRangeExecutionRuleDecoder<'a> {
175        #[inline]
176        fn get_limit(&self) -> usize {
177            self.limit
178        }
179
180        #[inline]
181        fn set_limit(&mut self, limit: usize) {
182            self.limit = limit;
183        }
184    }
185
186    impl<'a> PriceRangeExecutionRuleDecoder<'a> {
187        pub fn wrap(
188            mut self,
189            buf: ReadBuf<'a>,
190            offset: usize,
191            acting_block_length: u16,
192            acting_version: u16,
193        ) -> Self {
194            let limit = offset + acting_block_length as usize;
195            self.buf = buf;
196            self.initial_offset = offset;
197            self.offset = offset;
198            self.limit = limit;
199            self.acting_block_length = acting_block_length;
200            self.acting_version = acting_version;
201            self
202        }
203
204        #[inline]
205        pub fn encoded_length(&self) -> usize {
206            self.limit - self.offset
207        }
208
209        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
210            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
211            let acting_block_length = header.block_length();
212            let acting_version = header.version();
213
214            self.wrap(
215                header.parent().unwrap(),
216                offset + message_header_codec::ENCODED_LENGTH,
217                acting_block_length,
218                acting_version,
219            )
220        }
221
222        /// CONSTANT enum
223        #[inline]
224        pub fn rule_type(&self) -> execution_rule_type::ExecutionRuleType {
225            execution_rule_type::ExecutionRuleType::PriceRange
226        }
227
228        /// primitive field - 'REQUIRED'
229        #[inline]
230        pub fn multiplier_exponent(&self) -> i8 {
231            self.get_buf().get_i8_at(self.offset)
232        }
233
234        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
235        #[inline]
236        pub fn bid_limit_mult_up(&self) -> Option<i64> {
237            let value = self.get_buf().get_i64_at(self.offset + 1);
238            if value == -9223372036854775808_i64 {
239                None
240            } else {
241                Some(value)
242            }
243        }
244
245        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
246        #[inline]
247        pub fn bid_limit_mult_down(&self) -> Option<i64> {
248            let value = self.get_buf().get_i64_at(self.offset + 9);
249            if value == -9223372036854775808_i64 {
250                None
251            } else {
252                Some(value)
253            }
254        }
255
256        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
257        #[inline]
258        pub fn ask_limit_mult_up(&self) -> Option<i64> {
259            let value = self.get_buf().get_i64_at(self.offset + 17);
260            if value == -9223372036854775808_i64 {
261                None
262            } else {
263                Some(value)
264            }
265        }
266
267        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
268        #[inline]
269        pub fn ask_limit_mult_down(&self) -> Option<i64> {
270            let value = self.get_buf().get_i64_at(self.offset + 25);
271            if value == -9223372036854775808_i64 {
272                None
273            } else {
274                Some(value)
275            }
276        }
277    }
278} // end decoder
nautilus_binance/spot/sbe/generated/price_range_execution_rule_codec.rs

nautilus_binance/spot/sbe/generated/
price_range_execution_rule_codec.rs
