nautilus_binance/spot/sbe/generated/
cancel_replace_order_response_codec.rs

1pub use decoder::CancelReplaceOrderResponseDecoder;
2pub use encoder::CancelReplaceOrderResponseEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 2;
8pub const SBE_TEMPLATE_ID: u16 = 307;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct CancelReplaceOrderResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for CancelReplaceOrderResponseEncoder<'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 CancelReplaceOrderResponseEncoder<'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> CancelReplaceOrderResponseEncoder<'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        /// REQUIRED enum
67        #[inline]
68        pub fn cancel_result(&mut self, value: cancel_replace_status::CancelReplaceStatus) {
69            let offset = self.offset;
70            self.get_buf_mut().put_u8_at(offset, value as u8)
71        }
72
73        /// REQUIRED enum
74        #[inline]
75        pub fn new_order_result(&mut self, value: cancel_replace_status::CancelReplaceStatus) {
76            let offset = self.offset + 1;
77            self.get_buf_mut().put_u8_at(offset, value as u8)
78        }
79
80        /// VAR_DATA ENCODER - character encoding: 'None'
81        #[inline]
82        pub fn cancel_response(&mut self, value: &[u8]) {
83            let limit = self.get_limit();
84            let data_length = value.len();
85            self.set_limit(limit + 2 + data_length);
86            self.get_buf_mut().put_u16_at(limit, data_length as u16);
87            self.get_buf_mut().put_slice_at(limit + 2, value);
88        }
89
90        /// VAR_DATA ENCODER - character encoding: 'None'
91        #[inline]
92        pub fn new_order_response(&mut self, value: &[u8]) {
93            let limit = self.get_limit();
94            let data_length = value.len();
95            self.set_limit(limit + 4 + data_length);
96            self.get_buf_mut().put_u32_at(limit, data_length as u32);
97            self.get_buf_mut().put_slice_at(limit + 4, value);
98        }
99    }
100} // end encoder
101
102pub mod decoder {
103    use message_header_codec::*;
104
105    use super::*;
106
107    #[derive(Clone, Copy, Debug, Default)]
108    pub struct CancelReplaceOrderResponseDecoder<'a> {
109        buf: ReadBuf<'a>,
110        initial_offset: usize,
111        offset: usize,
112        limit: usize,
113        pub acting_block_length: u16,
114        pub acting_version: u16,
115    }
116
117    impl ActingVersion for CancelReplaceOrderResponseDecoder<'_> {
118        #[inline]
119        fn acting_version(&self) -> u16 {
120            self.acting_version
121        }
122    }
123
124    impl<'a> Reader<'a> for CancelReplaceOrderResponseDecoder<'a> {
125        #[inline]
126        fn get_buf(&self) -> &ReadBuf<'a> {
127            &self.buf
128        }
129    }
130
131    impl<'a> Decoder<'a> for CancelReplaceOrderResponseDecoder<'a> {
132        #[inline]
133        fn get_limit(&self) -> usize {
134            self.limit
135        }
136
137        #[inline]
138        fn set_limit(&mut self, limit: usize) {
139            self.limit = limit;
140        }
141    }
142
143    impl<'a> CancelReplaceOrderResponseDecoder<'a> {
144        pub fn wrap(
145            mut self,
146            buf: ReadBuf<'a>,
147            offset: usize,
148            acting_block_length: u16,
149            acting_version: u16,
150        ) -> Self {
151            let limit = offset + acting_block_length as usize;
152            self.buf = buf;
153            self.initial_offset = offset;
154            self.offset = offset;
155            self.limit = limit;
156            self.acting_block_length = acting_block_length;
157            self.acting_version = acting_version;
158            self
159        }
160
161        #[inline]
162        pub fn encoded_length(&self) -> usize {
163            self.limit - self.offset
164        }
165
166        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
167            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
168            let acting_block_length = header.block_length();
169            let acting_version = header.version();
170
171            self.wrap(
172                header.parent().unwrap(),
173                offset + message_header_codec::ENCODED_LENGTH,
174                acting_block_length,
175                acting_version,
176            )
177        }
178
179        /// REQUIRED enum
180        #[inline]
181        pub fn cancel_result(&self) -> cancel_replace_status::CancelReplaceStatus {
182            self.get_buf().get_u8_at(self.offset).into()
183        }
184
185        /// REQUIRED enum
186        #[inline]
187        pub fn new_order_result(&self) -> cancel_replace_status::CancelReplaceStatus {
188            self.get_buf().get_u8_at(self.offset + 1).into()
189        }
190
191        /// VAR_DATA DECODER - character encoding: 'None'
192        #[inline]
193        pub fn cancel_response_decoder(&mut self) -> (usize, usize) {
194            let offset = self.get_limit();
195            let data_length = self.get_buf().get_u16_at(offset) as usize;
196            self.set_limit(offset + 2 + data_length);
197            (offset + 2, data_length)
198        }
199
200        #[inline]
201        pub fn cancel_response_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
202            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
203            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
204        }
205
206        /// VAR_DATA DECODER - character encoding: 'None'
207        #[inline]
208        pub fn new_order_response_decoder(&mut self) -> (usize, usize) {
209            let offset = self.get_limit();
210            let data_length = self.get_buf().get_u32_at(offset) as usize;
211            self.set_limit(offset + 4 + data_length);
212            (offset + 4, data_length)
213        }
214
215        #[inline]
216        pub fn new_order_response_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
217            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
218            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
219        }
220    }
221} // end decoder
nautilus_binance/spot/sbe/generated/cancel_replace_order_response_codec.rs

nautilus_binance/spot/sbe/generated/
cancel_replace_order_response_codec.rs
