nautilus_binance/spot/sbe/generated/
price_ticker_symbol_response_codec.rs

1pub use decoder::PriceTickerSymbolResponseDecoder;
2pub use encoder::PriceTickerSymbolResponseEncoder;
3
4use super::*;
5pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
6
7pub const SBE_BLOCK_LENGTH: u16 = 9;
8pub const SBE_TEMPLATE_ID: u16 = 209;
9
10pub mod encoder {
11    use message_header_codec::*;
12
13    use super::*;
14
15    #[derive(Debug, Default)]
16    pub struct PriceTickerSymbolResponseEncoder<'a> {
17        buf: WriteBuf<'a>,
18        initial_offset: usize,
19        offset: usize,
20        limit: usize,
21    }
22
23    impl<'a> Writer<'a> for PriceTickerSymbolResponseEncoder<'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 PriceTickerSymbolResponseEncoder<'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> PriceTickerSymbolResponseEncoder<'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 'price'
82        /// - min value: -9223372036854775807
83        /// - max value: 9223372036854775807
84        /// - null value: -9223372036854775808_i64
85        /// - characterEncoding: null
86        /// - semanticType: null
87        /// - encodedOffset: 1
88        /// - encodedLength: 8
89        /// - version: 0
90        #[inline]
91        pub fn price(&mut self, value: i64) {
92            let offset = self.offset + 1;
93            self.get_buf_mut().put_i64_at(offset, value);
94        }
95
96        /// VAR_DATA ENCODER - character encoding: 'UTF-8'
97        #[inline]
98        pub fn symbol(&mut self, value: &str) {
99            let limit = self.get_limit();
100            let data_length = value.len();
101            self.set_limit(limit + 1 + data_length);
102            self.get_buf_mut().put_u8_at(limit, data_length as u8);
103            self.get_buf_mut().put_slice_at(limit + 1, value.as_bytes());
104        }
105    }
106} // end encoder
107
108pub mod decoder {
109    use message_header_codec::*;
110
111    use super::*;
112
113    #[derive(Clone, Copy, Debug, Default)]
114    pub struct PriceTickerSymbolResponseDecoder<'a> {
115        buf: ReadBuf<'a>,
116        initial_offset: usize,
117        offset: usize,
118        limit: usize,
119        pub acting_block_length: u16,
120        pub acting_version: u16,
121    }
122
123    impl ActingVersion for PriceTickerSymbolResponseDecoder<'_> {
124        #[inline]
125        fn acting_version(&self) -> u16 {
126            self.acting_version
127        }
128    }
129
130    impl<'a> Reader<'a> for PriceTickerSymbolResponseDecoder<'a> {
131        #[inline]
132        fn get_buf(&self) -> &ReadBuf<'a> {
133            &self.buf
134        }
135    }
136
137    impl<'a> Decoder<'a> for PriceTickerSymbolResponseDecoder<'a> {
138        #[inline]
139        fn get_limit(&self) -> usize {
140            self.limit
141        }
142
143        #[inline]
144        fn set_limit(&mut self, limit: usize) {
145            self.limit = limit;
146        }
147    }
148
149    impl<'a> PriceTickerSymbolResponseDecoder<'a> {
150        pub fn wrap(
151            mut self,
152            buf: ReadBuf<'a>,
153            offset: usize,
154            acting_block_length: u16,
155            acting_version: u16,
156        ) -> Self {
157            let limit = offset + acting_block_length as usize;
158            self.buf = buf;
159            self.initial_offset = offset;
160            self.offset = offset;
161            self.limit = limit;
162            self.acting_block_length = acting_block_length;
163            self.acting_version = acting_version;
164            self
165        }
166
167        #[inline]
168        pub fn encoded_length(&self) -> usize {
169            self.limit - self.offset
170        }
171
172        pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
173            debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
174            let acting_block_length = header.block_length();
175            let acting_version = header.version();
176
177            self.wrap(
178                header.parent().unwrap(),
179                offset + message_header_codec::ENCODED_LENGTH,
180                acting_block_length,
181                acting_version,
182            )
183        }
184
185        /// primitive field - 'REQUIRED'
186        #[inline]
187        pub fn price_exponent(&self) -> i8 {
188            self.get_buf().get_i8_at(self.offset)
189        }
190
191        /// primitive field - 'OPTIONAL' { null_value: '-9223372036854775808_i64' }
192        #[inline]
193        pub fn price(&self) -> Option<i64> {
194            let value = self.get_buf().get_i64_at(self.offset + 1);
195            if value == -9223372036854775808_i64 {
196                None
197            } else {
198                Some(value)
199            }
200        }
201
202        /// VAR_DATA DECODER - character encoding: 'UTF-8'
203        #[inline]
204        pub fn symbol_decoder(&mut self) -> (usize, usize) {
205            let offset = self.get_limit();
206            let data_length = self.get_buf().get_u8_at(offset) as usize;
207            self.set_limit(offset + 1 + data_length);
208            (offset + 1, data_length)
209        }
210
211        #[inline]
212        pub fn symbol_slice(&'a self, coordinates: (usize, usize)) -> &'a [u8] {
213            debug_assert!(self.get_limit() >= coordinates.0 + coordinates.1);
214            self.get_buf().get_slice_at(coordinates.0, coordinates.1)
215        }
216    }
217} // end decoder
nautilus_binance/spot/sbe/generated/price_ticker_symbol_response_codec.rs

nautilus_binance/spot/sbe/generated/
price_ticker_symbol_response_codec.rs
