1pub use root::*;
2
3const _: () = ::planus::check_version_compatibility("planus-1.1.1");
4
5#[no_implicit_prelude]
10#[allow(dead_code, clippy::needless_lifetimes)]
11mod root {
12 pub mod rusty_monitor {
17 pub mod schema {
22 #[derive(
27 Copy,
28 Clone,
29 Debug,
30 PartialEq,
31 Eq,
32 PartialOrd,
33 Ord,
34 Hash,
35 ::serde::Serialize,
36 ::serde::Deserialize,
37 )]
38 #[repr(i8)]
39 pub enum TradeSide {
40 Buy = 0,
42
43 Sell = 1,
45 }
46
47 impl TradeSide {
48 pub const ENUM_VALUES: [Self; 2] = [Self::Buy, Self::Sell];
50 }
51
52 impl ::core::convert::TryFrom<i8> for TradeSide {
53 type Error = ::planus::errors::UnknownEnumTagKind;
54 #[inline]
55 fn try_from(
56 value: i8,
57 ) -> ::core::result::Result<Self, ::planus::errors::UnknownEnumTagKind>
58 {
59 #[allow(clippy::match_single_binding)]
60 match value {
61 0 => ::core::result::Result::Ok(TradeSide::Buy),
62 1 => ::core::result::Result::Ok(TradeSide::Sell),
63
64 _ => ::core::result::Result::Err(::planus::errors::UnknownEnumTagKind {
65 tag: value as i128,
66 }),
67 }
68 }
69 }
70
71 impl ::core::convert::From<TradeSide> for i8 {
72 #[inline]
73 fn from(value: TradeSide) -> Self {
74 value as i8
75 }
76 }
77
78 unsafe impl ::planus::Primitive for TradeSide {
81 const ALIGNMENT: usize = 1;
82 const SIZE: usize = 1;
83 }
84
85 impl ::planus::WriteAsPrimitive<TradeSide> for TradeSide {
86 #[inline]
87 fn write<const N: usize>(
88 &self,
89 cursor: ::planus::Cursor<'_, N>,
90 buffer_position: u32,
91 ) {
92 (*self as i8).write(cursor, buffer_position);
93 }
94 }
95
96 impl ::planus::WriteAs<TradeSide> for TradeSide {
97 type Prepared = Self;
98
99 #[inline]
100 fn prepare(&self, _builder: &mut ::planus::Builder) -> TradeSide {
101 *self
102 }
103 }
104
105 impl ::planus::WriteAsDefault<TradeSide, TradeSide> for TradeSide {
106 type Prepared = Self;
107
108 #[inline]
109 fn prepare(
110 &self,
111 _builder: &mut ::planus::Builder,
112 default: &TradeSide,
113 ) -> ::core::option::Option<TradeSide> {
114 if self == default {
115 ::core::option::Option::None
116 } else {
117 ::core::option::Option::Some(*self)
118 }
119 }
120 }
121
122 impl ::planus::WriteAsOptional<TradeSide> for TradeSide {
123 type Prepared = Self;
124
125 #[inline]
126 fn prepare(
127 &self,
128 _builder: &mut ::planus::Builder,
129 ) -> ::core::option::Option<TradeSide> {
130 ::core::option::Option::Some(*self)
131 }
132 }
133
134 impl<'buf> ::planus::TableRead<'buf> for TradeSide {
135 #[inline]
136 fn from_buffer(
137 buffer: ::planus::SliceWithStartOffset<'buf>,
138 offset: usize,
139 ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
140 let n: i8 = ::planus::TableRead::from_buffer(buffer, offset)?;
141 ::core::result::Result::Ok(::core::convert::TryInto::try_into(n)?)
142 }
143 }
144
145 impl<'buf> ::planus::VectorReadInner<'buf> for TradeSide {
146 type Error = ::planus::errors::UnknownEnumTag;
147 const STRIDE: usize = 1;
148 #[inline]
149 unsafe fn from_buffer(
150 buffer: ::planus::SliceWithStartOffset<'buf>,
151 offset: usize,
152 ) -> ::core::result::Result<Self, ::planus::errors::UnknownEnumTag>
153 {
154 let value = unsafe { *buffer.buffer.get_unchecked(offset) as i8 };
155 let value: ::core::result::Result<Self, _> =
156 ::core::convert::TryInto::try_into(value);
157 value.map_err(|error_kind| {
158 error_kind.with_error_location(
159 "TradeSide",
160 "VectorRead::from_buffer",
161 buffer.offset_from_start,
162 )
163 })
164 }
165 }
166
167 unsafe impl ::planus::VectorWrite<TradeSide> for TradeSide {
171 const STRIDE: usize = 1;
172
173 type Value = Self;
174
175 #[inline]
176 fn prepare(&self, _builder: &mut ::planus::Builder) -> Self {
177 *self
178 }
179
180 #[inline]
181 unsafe fn write_values(
182 values: &[Self],
183 bytes: *mut ::core::mem::MaybeUninit<u8>,
184 buffer_position: u32,
185 ) {
186 let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 1];
187 for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
188 ::planus::WriteAsPrimitive::write(
189 v,
190 ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
191 buffer_position - i as u32,
192 );
193 }
194 }
195 }
196
197 #[derive(
202 Clone,
203 Debug,
204 PartialEq,
205 PartialOrd,
206 Eq,
207 Ord,
208 Hash,
209 ::serde::Serialize,
210 ::serde::Deserialize,
211 )]
212 pub struct Trade {
213 pub timestamp_exchange: u64,
215 pub timestamp_system: u64,
217 pub symbol: ::planus::alloc::string::String,
219 pub exchange: ::planus::alloc::string::String,
221 pub price: ::planus::alloc::string::String,
223 pub quantity: ::planus::alloc::string::String,
225 pub side: self::TradeSide,
227 pub trade_id: ::core::option::Option<::planus::alloc::string::String>,
229 pub buyer_order_id: ::core::option::Option<::planus::alloc::string::String>,
231 pub seller_order_id: ::core::option::Option<::planus::alloc::string::String>,
233 pub sequence: u64,
235 }
236
237 #[allow(clippy::derivable_impls)]
238 impl ::core::default::Default for Trade {
239 fn default() -> Self {
240 Self {
241 timestamp_exchange: 0,
242 timestamp_system: 0,
243 symbol: ::core::default::Default::default(),
244 exchange: ::core::default::Default::default(),
245 price: ::core::default::Default::default(),
246 quantity: ::core::default::Default::default(),
247 side: self::TradeSide::Buy,
248 trade_id: ::core::default::Default::default(),
249 buyer_order_id: ::core::default::Default::default(),
250 seller_order_id: ::core::default::Default::default(),
251 sequence: 0,
252 }
253 }
254 }
255
256 impl Trade {
257 #[inline]
259 pub const fn builder() -> TradeBuilder<()> {
260 TradeBuilder(())
261 }
262
263 #[allow(clippy::too_many_arguments)]
264 pub fn create(
265 builder: &mut ::planus::Builder,
266 field_timestamp_exchange: impl ::planus::WriteAsDefault<u64, u64>,
267 field_timestamp_system: impl ::planus::WriteAsDefault<u64, u64>,
268 field_symbol: impl ::planus::WriteAs<::planus::Offset<str>>,
269 field_exchange: impl ::planus::WriteAs<::planus::Offset<str>>,
270 field_price: impl ::planus::WriteAs<::planus::Offset<str>>,
271 field_quantity: impl ::planus::WriteAs<::planus::Offset<str>>,
272 field_side: impl ::planus::WriteAsDefault<self::TradeSide, self::TradeSide>,
273 field_trade_id: impl ::planus::WriteAsOptional<
274 ::planus::Offset<::core::primitive::str>,
275 >,
276 field_buyer_order_id: impl ::planus::WriteAsOptional<
277 ::planus::Offset<::core::primitive::str>,
278 >,
279 field_seller_order_id: impl ::planus::WriteAsOptional<
280 ::planus::Offset<::core::primitive::str>,
281 >,
282 field_sequence: impl ::planus::WriteAsDefault<u64, u64>,
283 ) -> ::planus::Offset<Self> {
284 let prepared_timestamp_exchange = field_timestamp_exchange.prepare(builder, &0);
285 let prepared_timestamp_system = field_timestamp_system.prepare(builder, &0);
286 let prepared_symbol = field_symbol.prepare(builder);
287 let prepared_exchange = field_exchange.prepare(builder);
288 let prepared_price = field_price.prepare(builder);
289 let prepared_quantity = field_quantity.prepare(builder);
290 let prepared_side = field_side.prepare(builder, &self::TradeSide::Buy);
291 let prepared_trade_id = field_trade_id.prepare(builder);
292 let prepared_buyer_order_id = field_buyer_order_id.prepare(builder);
293 let prepared_seller_order_id = field_seller_order_id.prepare(builder);
294 let prepared_sequence = field_sequence.prepare(builder, &0);
295
296 let mut table_writer: ::planus::table_writer::TableWriter<26> =
297 ::core::default::Default::default();
298 if prepared_timestamp_exchange.is_some() {
299 table_writer.write_entry::<u64>(0);
300 }
301 if prepared_timestamp_system.is_some() {
302 table_writer.write_entry::<u64>(1);
303 }
304 if prepared_sequence.is_some() {
305 table_writer.write_entry::<u64>(10);
306 }
307 table_writer.write_entry::<::planus::Offset<str>>(2);
308 table_writer.write_entry::<::planus::Offset<str>>(3);
309 table_writer.write_entry::<::planus::Offset<str>>(4);
310 table_writer.write_entry::<::planus::Offset<str>>(5);
311 if prepared_trade_id.is_some() {
312 table_writer.write_entry::<::planus::Offset<str>>(7);
313 }
314 if prepared_buyer_order_id.is_some() {
315 table_writer.write_entry::<::planus::Offset<str>>(8);
316 }
317 if prepared_seller_order_id.is_some() {
318 table_writer.write_entry::<::planus::Offset<str>>(9);
319 }
320 if prepared_side.is_some() {
321 table_writer.write_entry::<self::TradeSide>(6);
322 }
323
324 unsafe {
325 table_writer.finish(builder, |object_writer| {
326 if let ::core::option::Option::Some(prepared_timestamp_exchange) =
327 prepared_timestamp_exchange
328 {
329 object_writer.write::<_, _, 8>(&prepared_timestamp_exchange);
330 }
331 if let ::core::option::Option::Some(prepared_timestamp_system) =
332 prepared_timestamp_system
333 {
334 object_writer.write::<_, _, 8>(&prepared_timestamp_system);
335 }
336 if let ::core::option::Option::Some(prepared_sequence) =
337 prepared_sequence
338 {
339 object_writer.write::<_, _, 8>(&prepared_sequence);
340 }
341 object_writer.write::<_, _, 4>(&prepared_symbol);
342 object_writer.write::<_, _, 4>(&prepared_exchange);
343 object_writer.write::<_, _, 4>(&prepared_price);
344 object_writer.write::<_, _, 4>(&prepared_quantity);
345 if let ::core::option::Option::Some(prepared_trade_id) =
346 prepared_trade_id
347 {
348 object_writer.write::<_, _, 4>(&prepared_trade_id);
349 }
350 if let ::core::option::Option::Some(prepared_buyer_order_id) =
351 prepared_buyer_order_id
352 {
353 object_writer.write::<_, _, 4>(&prepared_buyer_order_id);
354 }
355 if let ::core::option::Option::Some(prepared_seller_order_id) =
356 prepared_seller_order_id
357 {
358 object_writer.write::<_, _, 4>(&prepared_seller_order_id);
359 }
360 if let ::core::option::Option::Some(prepared_side) = prepared_side {
361 object_writer.write::<_, _, 1>(&prepared_side);
362 }
363 });
364 }
365 builder.current_offset()
366 }
367 }
368
369 impl ::planus::WriteAs<::planus::Offset<Trade>> for Trade {
370 type Prepared = ::planus::Offset<Self>;
371
372 #[inline]
373 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<Trade> {
374 ::planus::WriteAsOffset::prepare(self, builder)
375 }
376 }
377
378 impl ::planus::WriteAsOptional<::planus::Offset<Trade>> for Trade {
379 type Prepared = ::planus::Offset<Self>;
380
381 #[inline]
382 fn prepare(
383 &self,
384 builder: &mut ::planus::Builder,
385 ) -> ::core::option::Option<::planus::Offset<Trade>> {
386 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
387 }
388 }
389
390 impl ::planus::WriteAsOffset<Trade> for Trade {
391 #[inline]
392 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<Trade> {
393 Trade::create(
394 builder,
395 self.timestamp_exchange,
396 self.timestamp_system,
397 &self.symbol,
398 &self.exchange,
399 &self.price,
400 &self.quantity,
401 self.side,
402 &self.trade_id,
403 &self.buyer_order_id,
404 &self.seller_order_id,
405 self.sequence,
406 )
407 }
408 }
409
410 #[derive(Debug)]
414 #[must_use]
415 pub struct TradeBuilder<State>(State);
416
417 impl TradeBuilder<()> {
418 #[inline]
420 #[allow(clippy::type_complexity)]
421 pub const fn timestamp_exchange<T0>(self, value: T0) -> TradeBuilder<(T0,)>
422 where
423 T0: ::planus::WriteAsDefault<u64, u64>,
424 {
425 TradeBuilder((value,))
426 }
427
428 #[inline]
430 #[allow(clippy::type_complexity)]
431 pub const fn timestamp_exchange_as_default(
432 self,
433 ) -> TradeBuilder<(::planus::DefaultValue,)> {
434 self.timestamp_exchange(::planus::DefaultValue)
435 }
436 }
437
438 impl<T0> TradeBuilder<(T0,)> {
439 #[inline]
441 #[allow(clippy::type_complexity)]
442 pub fn timestamp_system<T1>(self, value: T1) -> TradeBuilder<(T0, T1)>
443 where
444 T1: ::planus::WriteAsDefault<u64, u64>,
445 {
446 let (v0,) = self.0;
447 TradeBuilder((v0, value))
448 }
449
450 #[inline]
452 #[allow(clippy::type_complexity)]
453 pub fn timestamp_system_as_default(
454 self,
455 ) -> TradeBuilder<(T0, ::planus::DefaultValue)> {
456 self.timestamp_system(::planus::DefaultValue)
457 }
458 }
459
460 impl<T0, T1> TradeBuilder<(T0, T1)> {
461 #[inline]
463 #[allow(clippy::type_complexity)]
464 pub fn symbol<T2>(self, value: T2) -> TradeBuilder<(T0, T1, T2)>
465 where
466 T2: ::planus::WriteAs<::planus::Offset<str>>,
467 {
468 let (v0, v1) = self.0;
469 TradeBuilder((v0, v1, value))
470 }
471 }
472
473 impl<T0, T1, T2> TradeBuilder<(T0, T1, T2)> {
474 #[inline]
476 #[allow(clippy::type_complexity)]
477 pub fn exchange<T3>(self, value: T3) -> TradeBuilder<(T0, T1, T2, T3)>
478 where
479 T3: ::planus::WriteAs<::planus::Offset<str>>,
480 {
481 let (v0, v1, v2) = self.0;
482 TradeBuilder((v0, v1, v2, value))
483 }
484 }
485
486 impl<T0, T1, T2, T3> TradeBuilder<(T0, T1, T2, T3)> {
487 #[inline]
489 #[allow(clippy::type_complexity)]
490 pub fn price<T4>(self, value: T4) -> TradeBuilder<(T0, T1, T2, T3, T4)>
491 where
492 T4: ::planus::WriteAs<::planus::Offset<str>>,
493 {
494 let (v0, v1, v2, v3) = self.0;
495 TradeBuilder((v0, v1, v2, v3, value))
496 }
497 }
498
499 impl<T0, T1, T2, T3, T4> TradeBuilder<(T0, T1, T2, T3, T4)> {
500 #[inline]
502 #[allow(clippy::type_complexity)]
503 pub fn quantity<T5>(self, value: T5) -> TradeBuilder<(T0, T1, T2, T3, T4, T5)>
504 where
505 T5: ::planus::WriteAs<::planus::Offset<str>>,
506 {
507 let (v0, v1, v2, v3, v4) = self.0;
508 TradeBuilder((v0, v1, v2, v3, v4, value))
509 }
510 }
511
512 impl<T0, T1, T2, T3, T4, T5> TradeBuilder<(T0, T1, T2, T3, T4, T5)> {
513 #[inline]
515 #[allow(clippy::type_complexity)]
516 pub fn side<T6>(self, value: T6) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6)>
517 where
518 T6: ::planus::WriteAsDefault<self::TradeSide, self::TradeSide>,
519 {
520 let (v0, v1, v2, v3, v4, v5) = self.0;
521 TradeBuilder((v0, v1, v2, v3, v4, v5, value))
522 }
523
524 #[inline]
526 #[allow(clippy::type_complexity)]
527 pub fn side_as_default(
528 self,
529 ) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, ::planus::DefaultValue)>
530 {
531 self.side(::planus::DefaultValue)
532 }
533 }
534
535 impl<T0, T1, T2, T3, T4, T5, T6> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6)> {
536 #[inline]
538 #[allow(clippy::type_complexity)]
539 pub fn trade_id<T7>(
540 self,
541 value: T7,
542 ) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)>
543 where
544 T7: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
545 {
546 let (v0, v1, v2, v3, v4, v5, v6) = self.0;
547 TradeBuilder((v0, v1, v2, v3, v4, v5, v6, value))
548 }
549
550 #[inline]
552 #[allow(clippy::type_complexity)]
553 pub fn trade_id_as_null(self) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, ())> {
554 self.trade_id(())
555 }
556 }
557
558 impl<T0, T1, T2, T3, T4, T5, T6, T7> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> {
559 #[inline]
561 #[allow(clippy::type_complexity)]
562 pub fn buyer_order_id<T8>(
563 self,
564 value: T8,
565 ) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
566 where
567 T8: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
568 {
569 let (v0, v1, v2, v3, v4, v5, v6, v7) = self.0;
570 TradeBuilder((v0, v1, v2, v3, v4, v5, v6, v7, value))
571 }
572
573 #[inline]
575 #[allow(clippy::type_complexity)]
576 pub fn buyer_order_id_as_null(
577 self,
578 ) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, ())> {
579 self.buyer_order_id(())
580 }
581 }
582
583 impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {
584 #[inline]
586 #[allow(clippy::type_complexity)]
587 pub fn seller_order_id<T9>(
588 self,
589 value: T9,
590 ) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
591 where
592 T9: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
593 {
594 let (v0, v1, v2, v3, v4, v5, v6, v7, v8) = self.0;
595 TradeBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, value))
596 }
597
598 #[inline]
600 #[allow(clippy::type_complexity)]
601 pub fn seller_order_id_as_null(
602 self,
603 ) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, ())> {
604 self.seller_order_id(())
605 }
606 }
607
608 impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
609 TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
610 {
611 #[inline]
613 #[allow(clippy::type_complexity)]
614 pub fn sequence<T10>(
615 self,
616 value: T10,
617 ) -> TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
618 where
619 T10: ::planus::WriteAsDefault<u64, u64>,
620 {
621 let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) = self.0;
622 TradeBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, value))
623 }
624
625 #[inline]
627 #[allow(clippy::type_complexity)]
628 pub fn sequence_as_default(
629 self,
630 ) -> TradeBuilder<(
631 T0,
632 T1,
633 T2,
634 T3,
635 T4,
636 T5,
637 T6,
638 T7,
639 T8,
640 T9,
641 ::planus::DefaultValue,
642 )> {
643 self.sequence(::planus::DefaultValue)
644 }
645 }
646
647 impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
648 TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
649 {
650 #[inline]
652 pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset<Trade>
653 where
654 Self: ::planus::WriteAsOffset<Trade>,
655 {
656 ::planus::WriteAsOffset::prepare(&self, builder)
657 }
658 }
659
660 impl<
661 T0: ::planus::WriteAsDefault<u64, u64>,
662 T1: ::planus::WriteAsDefault<u64, u64>,
663 T2: ::planus::WriteAs<::planus::Offset<str>>,
664 T3: ::planus::WriteAs<::planus::Offset<str>>,
665 T4: ::planus::WriteAs<::planus::Offset<str>>,
666 T5: ::planus::WriteAs<::planus::Offset<str>>,
667 T6: ::planus::WriteAsDefault<self::TradeSide, self::TradeSide>,
668 T7: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
669 T8: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
670 T9: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
671 T10: ::planus::WriteAsDefault<u64, u64>,
672 > ::planus::WriteAs<::planus::Offset<Trade>>
673 for TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
674 {
675 type Prepared = ::planus::Offset<Trade>;
676
677 #[inline]
678 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<Trade> {
679 ::planus::WriteAsOffset::prepare(self, builder)
680 }
681 }
682
683 impl<
684 T0: ::planus::WriteAsDefault<u64, u64>,
685 T1: ::planus::WriteAsDefault<u64, u64>,
686 T2: ::planus::WriteAs<::planus::Offset<str>>,
687 T3: ::planus::WriteAs<::planus::Offset<str>>,
688 T4: ::planus::WriteAs<::planus::Offset<str>>,
689 T5: ::planus::WriteAs<::planus::Offset<str>>,
690 T6: ::planus::WriteAsDefault<self::TradeSide, self::TradeSide>,
691 T7: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
692 T8: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
693 T9: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
694 T10: ::planus::WriteAsDefault<u64, u64>,
695 > ::planus::WriteAsOptional<::planus::Offset<Trade>>
696 for TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
697 {
698 type Prepared = ::planus::Offset<Trade>;
699
700 #[inline]
701 fn prepare(
702 &self,
703 builder: &mut ::planus::Builder,
704 ) -> ::core::option::Option<::planus::Offset<Trade>> {
705 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
706 }
707 }
708
709 impl<
710 T0: ::planus::WriteAsDefault<u64, u64>,
711 T1: ::planus::WriteAsDefault<u64, u64>,
712 T2: ::planus::WriteAs<::planus::Offset<str>>,
713 T3: ::planus::WriteAs<::planus::Offset<str>>,
714 T4: ::planus::WriteAs<::planus::Offset<str>>,
715 T5: ::planus::WriteAs<::planus::Offset<str>>,
716 T6: ::planus::WriteAsDefault<self::TradeSide, self::TradeSide>,
717 T7: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
718 T8: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
719 T9: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
720 T10: ::planus::WriteAsDefault<u64, u64>,
721 > ::planus::WriteAsOffset<Trade>
722 for TradeBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
723 {
724 #[inline]
725 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<Trade> {
726 let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) = &self.0;
727 Trade::create(builder, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
728 }
729 }
730
731 #[derive(Copy, Clone)]
733 pub struct TradeRef<'a>(::planus::table_reader::Table<'a>);
734
735 impl<'a> TradeRef<'a> {
736 #[inline]
738 pub fn timestamp_exchange(&self) -> ::planus::Result<u64> {
739 ::core::result::Result::Ok(
740 self.0
741 .access(0, "Trade", "timestamp_exchange")?
742 .unwrap_or(0),
743 )
744 }
745
746 #[inline]
748 pub fn timestamp_system(&self) -> ::planus::Result<u64> {
749 ::core::result::Result::Ok(
750 self.0.access(1, "Trade", "timestamp_system")?.unwrap_or(0),
751 )
752 }
753
754 #[inline]
756 pub fn symbol(&self) -> ::planus::Result<&'a ::core::primitive::str> {
757 self.0.access_required(2, "Trade", "symbol")
758 }
759
760 #[inline]
762 pub fn exchange(&self) -> ::planus::Result<&'a ::core::primitive::str> {
763 self.0.access_required(3, "Trade", "exchange")
764 }
765
766 #[inline]
768 pub fn price(&self) -> ::planus::Result<&'a ::core::primitive::str> {
769 self.0.access_required(4, "Trade", "price")
770 }
771
772 #[inline]
774 pub fn quantity(&self) -> ::planus::Result<&'a ::core::primitive::str> {
775 self.0.access_required(5, "Trade", "quantity")
776 }
777
778 #[inline]
780 pub fn side(&self) -> ::planus::Result<self::TradeSide> {
781 ::core::result::Result::Ok(
782 self.0
783 .access(6, "Trade", "side")?
784 .unwrap_or(self::TradeSide::Buy),
785 )
786 }
787
788 #[inline]
790 pub fn trade_id(
791 &self,
792 ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>>
793 {
794 self.0.access(7, "Trade", "trade_id")
795 }
796
797 #[inline]
799 pub fn buyer_order_id(
800 &self,
801 ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>>
802 {
803 self.0.access(8, "Trade", "buyer_order_id")
804 }
805
806 #[inline]
808 pub fn seller_order_id(
809 &self,
810 ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>>
811 {
812 self.0.access(9, "Trade", "seller_order_id")
813 }
814
815 #[inline]
817 pub fn sequence(&self) -> ::planus::Result<u64> {
818 ::core::result::Result::Ok(self.0.access(10, "Trade", "sequence")?.unwrap_or(0))
819 }
820 }
821
822 impl<'a> ::core::fmt::Debug for TradeRef<'a> {
823 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
824 let mut f = f.debug_struct("TradeRef");
825 f.field("timestamp_exchange", &self.timestamp_exchange());
826 f.field("timestamp_system", &self.timestamp_system());
827 f.field("symbol", &self.symbol());
828 f.field("exchange", &self.exchange());
829 f.field("price", &self.price());
830 f.field("quantity", &self.quantity());
831 f.field("side", &self.side());
832 if let ::core::option::Option::Some(field_trade_id) =
833 self.trade_id().transpose()
834 {
835 f.field("trade_id", &field_trade_id);
836 }
837 if let ::core::option::Option::Some(field_buyer_order_id) =
838 self.buyer_order_id().transpose()
839 {
840 f.field("buyer_order_id", &field_buyer_order_id);
841 }
842 if let ::core::option::Option::Some(field_seller_order_id) =
843 self.seller_order_id().transpose()
844 {
845 f.field("seller_order_id", &field_seller_order_id);
846 }
847 f.field("sequence", &self.sequence());
848 f.finish()
849 }
850 }
851
852 impl<'a> ::core::convert::TryFrom<TradeRef<'a>> for Trade {
853 type Error = ::planus::Error;
854
855 #[allow(unreachable_code)]
856 fn try_from(value: TradeRef<'a>) -> ::planus::Result<Self> {
857 ::core::result::Result::Ok(Self {
858 timestamp_exchange: ::core::convert::TryInto::try_into(
859 value.timestamp_exchange()?,
860 )?,
861 timestamp_system: ::core::convert::TryInto::try_into(
862 value.timestamp_system()?,
863 )?,
864 symbol: ::core::convert::Into::into(value.symbol()?),
865 exchange: ::core::convert::Into::into(value.exchange()?),
866 price: ::core::convert::Into::into(value.price()?),
867 quantity: ::core::convert::Into::into(value.quantity()?),
868 side: ::core::convert::TryInto::try_into(value.side()?)?,
869 trade_id: value.trade_id()?.map(::core::convert::Into::into),
870 buyer_order_id: value.buyer_order_id()?.map(::core::convert::Into::into),
871 seller_order_id: value.seller_order_id()?.map(::core::convert::Into::into),
872 sequence: ::core::convert::TryInto::try_into(value.sequence()?)?,
873 })
874 }
875 }
876
877 impl<'a> ::planus::TableRead<'a> for TradeRef<'a> {
878 #[inline]
879 fn from_buffer(
880 buffer: ::planus::SliceWithStartOffset<'a>,
881 offset: usize,
882 ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
883 ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
884 buffer, offset,
885 )?))
886 }
887 }
888
889 impl<'a> ::planus::VectorReadInner<'a> for TradeRef<'a> {
890 type Error = ::planus::Error;
891 const STRIDE: usize = 4;
892
893 unsafe fn from_buffer(
894 buffer: ::planus::SliceWithStartOffset<'a>,
895 offset: usize,
896 ) -> ::planus::Result<Self> {
897 ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
898 error_kind.with_error_location(
899 "[TradeRef]",
900 "get",
901 buffer.offset_from_start,
902 )
903 })
904 }
905 }
906
907 unsafe impl ::planus::VectorWrite<::planus::Offset<Trade>> for Trade {
911 type Value = ::planus::Offset<Trade>;
912 const STRIDE: usize = 4;
913 #[inline]
914 fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
915 ::planus::WriteAs::prepare(self, builder)
916 }
917
918 #[inline]
919 unsafe fn write_values(
920 values: &[::planus::Offset<Trade>],
921 bytes: *mut ::core::mem::MaybeUninit<u8>,
922 buffer_position: u32,
923 ) {
924 let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
925 for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
926 ::planus::WriteAsPrimitive::write(
927 v,
928 ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
929 buffer_position - (Self::STRIDE * i) as u32,
930 );
931 }
932 }
933 }
934
935 impl<'a> ::planus::ReadAsRoot<'a> for TradeRef<'a> {
936 fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
937 ::planus::TableRead::from_buffer(
938 ::planus::SliceWithStartOffset {
939 buffer: slice,
940 offset_from_start: 0,
941 },
942 0,
943 )
944 .map_err(|error_kind| {
945 error_kind.with_error_location("[TradeRef]", "read_as_root", 0)
946 })
947 }
948 }
949
950 #[derive(
955 Clone,
956 Debug,
957 PartialEq,
958 PartialOrd,
959 Eq,
960 Ord,
961 Hash,
962 ::serde::Serialize,
963 ::serde::Deserialize,
964 )]
965 pub struct TradesBatch {
966 pub trades: ::planus::alloc::vec::Vec<self::Trade>,
968 pub batch_timestamp: u64,
970 pub batch_id: ::core::option::Option<::planus::alloc::string::String>,
972 }
973
974 #[allow(clippy::derivable_impls)]
975 impl ::core::default::Default for TradesBatch {
976 fn default() -> Self {
977 Self {
978 trades: ::core::default::Default::default(),
979 batch_timestamp: 0,
980 batch_id: ::core::default::Default::default(),
981 }
982 }
983 }
984
985 impl TradesBatch {
986 #[inline]
988 pub const fn builder() -> TradesBatchBuilder<()> {
989 TradesBatchBuilder(())
990 }
991
992 #[allow(clippy::too_many_arguments)]
993 pub fn create(
994 builder: &mut ::planus::Builder,
995 field_trades: impl ::planus::WriteAs<
996 ::planus::Offset<[::planus::Offset<self::Trade>]>,
997 >,
998 field_batch_timestamp: impl ::planus::WriteAsDefault<u64, u64>,
999 field_batch_id: impl ::planus::WriteAsOptional<
1000 ::planus::Offset<::core::primitive::str>,
1001 >,
1002 ) -> ::planus::Offset<Self> {
1003 let prepared_trades = field_trades.prepare(builder);
1004 let prepared_batch_timestamp = field_batch_timestamp.prepare(builder, &0);
1005 let prepared_batch_id = field_batch_id.prepare(builder);
1006
1007 let mut table_writer: ::planus::table_writer::TableWriter<10> =
1008 ::core::default::Default::default();
1009 if prepared_batch_timestamp.is_some() {
1010 table_writer.write_entry::<u64>(1);
1011 }
1012 table_writer
1013 .write_entry::<::planus::Offset<[::planus::Offset<self::Trade>]>>(0);
1014 if prepared_batch_id.is_some() {
1015 table_writer.write_entry::<::planus::Offset<str>>(2);
1016 }
1017
1018 unsafe {
1019 table_writer.finish(builder, |object_writer| {
1020 if let ::core::option::Option::Some(prepared_batch_timestamp) =
1021 prepared_batch_timestamp
1022 {
1023 object_writer.write::<_, _, 8>(&prepared_batch_timestamp);
1024 }
1025 object_writer.write::<_, _, 4>(&prepared_trades);
1026 if let ::core::option::Option::Some(prepared_batch_id) =
1027 prepared_batch_id
1028 {
1029 object_writer.write::<_, _, 4>(&prepared_batch_id);
1030 }
1031 });
1032 }
1033 builder.current_offset()
1034 }
1035 }
1036
1037 impl ::planus::WriteAs<::planus::Offset<TradesBatch>> for TradesBatch {
1038 type Prepared = ::planus::Offset<Self>;
1039
1040 #[inline]
1041 fn prepare(
1042 &self,
1043 builder: &mut ::planus::Builder,
1044 ) -> ::planus::Offset<TradesBatch> {
1045 ::planus::WriteAsOffset::prepare(self, builder)
1046 }
1047 }
1048
1049 impl ::planus::WriteAsOptional<::planus::Offset<TradesBatch>> for TradesBatch {
1050 type Prepared = ::planus::Offset<Self>;
1051
1052 #[inline]
1053 fn prepare(
1054 &self,
1055 builder: &mut ::planus::Builder,
1056 ) -> ::core::option::Option<::planus::Offset<TradesBatch>> {
1057 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1058 }
1059 }
1060
1061 impl ::planus::WriteAsOffset<TradesBatch> for TradesBatch {
1062 #[inline]
1063 fn prepare(
1064 &self,
1065 builder: &mut ::planus::Builder,
1066 ) -> ::planus::Offset<TradesBatch> {
1067 TradesBatch::create(builder, &self.trades, self.batch_timestamp, &self.batch_id)
1068 }
1069 }
1070
1071 #[derive(Debug)]
1075 #[must_use]
1076 pub struct TradesBatchBuilder<State>(State);
1077
1078 impl TradesBatchBuilder<()> {
1079 #[inline]
1081 #[allow(clippy::type_complexity)]
1082 pub const fn trades<T0>(self, value: T0) -> TradesBatchBuilder<(T0,)>
1083 where
1084 T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::Trade>]>>,
1085 {
1086 TradesBatchBuilder((value,))
1087 }
1088 }
1089
1090 impl<T0> TradesBatchBuilder<(T0,)> {
1091 #[inline]
1093 #[allow(clippy::type_complexity)]
1094 pub fn batch_timestamp<T1>(self, value: T1) -> TradesBatchBuilder<(T0, T1)>
1095 where
1096 T1: ::planus::WriteAsDefault<u64, u64>,
1097 {
1098 let (v0,) = self.0;
1099 TradesBatchBuilder((v0, value))
1100 }
1101
1102 #[inline]
1104 #[allow(clippy::type_complexity)]
1105 pub fn batch_timestamp_as_default(
1106 self,
1107 ) -> TradesBatchBuilder<(T0, ::planus::DefaultValue)> {
1108 self.batch_timestamp(::planus::DefaultValue)
1109 }
1110 }
1111
1112 impl<T0, T1> TradesBatchBuilder<(T0, T1)> {
1113 #[inline]
1115 #[allow(clippy::type_complexity)]
1116 pub fn batch_id<T2>(self, value: T2) -> TradesBatchBuilder<(T0, T1, T2)>
1117 where
1118 T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1119 {
1120 let (v0, v1) = self.0;
1121 TradesBatchBuilder((v0, v1, value))
1122 }
1123
1124 #[inline]
1126 #[allow(clippy::type_complexity)]
1127 pub fn batch_id_as_null(self) -> TradesBatchBuilder<(T0, T1, ())> {
1128 self.batch_id(())
1129 }
1130 }
1131
1132 impl<T0, T1, T2> TradesBatchBuilder<(T0, T1, T2)> {
1133 #[inline]
1135 pub fn finish(
1136 self,
1137 builder: &mut ::planus::Builder,
1138 ) -> ::planus::Offset<TradesBatch>
1139 where
1140 Self: ::planus::WriteAsOffset<TradesBatch>,
1141 {
1142 ::planus::WriteAsOffset::prepare(&self, builder)
1143 }
1144 }
1145
1146 impl<
1147 T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::Trade>]>>,
1148 T1: ::planus::WriteAsDefault<u64, u64>,
1149 T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1150 > ::planus::WriteAs<::planus::Offset<TradesBatch>>
1151 for TradesBatchBuilder<(T0, T1, T2)>
1152 {
1153 type Prepared = ::planus::Offset<TradesBatch>;
1154
1155 #[inline]
1156 fn prepare(
1157 &self,
1158 builder: &mut ::planus::Builder,
1159 ) -> ::planus::Offset<TradesBatch> {
1160 ::planus::WriteAsOffset::prepare(self, builder)
1161 }
1162 }
1163
1164 impl<
1165 T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::Trade>]>>,
1166 T1: ::planus::WriteAsDefault<u64, u64>,
1167 T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1168 > ::planus::WriteAsOptional<::planus::Offset<TradesBatch>>
1169 for TradesBatchBuilder<(T0, T1, T2)>
1170 {
1171 type Prepared = ::planus::Offset<TradesBatch>;
1172
1173 #[inline]
1174 fn prepare(
1175 &self,
1176 builder: &mut ::planus::Builder,
1177 ) -> ::core::option::Option<::planus::Offset<TradesBatch>> {
1178 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1179 }
1180 }
1181
1182 impl<
1183 T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::Trade>]>>,
1184 T1: ::planus::WriteAsDefault<u64, u64>,
1185 T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1186 > ::planus::WriteAsOffset<TradesBatch> for TradesBatchBuilder<(T0, T1, T2)>
1187 {
1188 #[inline]
1189 fn prepare(
1190 &self,
1191 builder: &mut ::planus::Builder,
1192 ) -> ::planus::Offset<TradesBatch> {
1193 let (v0, v1, v2) = &self.0;
1194 TradesBatch::create(builder, v0, v1, v2)
1195 }
1196 }
1197
1198 #[derive(Copy, Clone)]
1200 pub struct TradesBatchRef<'a>(::planus::table_reader::Table<'a>);
1201
1202 impl<'a> TradesBatchRef<'a> {
1203 #[inline]
1205 pub fn trades(
1206 &self,
1207 ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result<self::TradeRef<'a>>>>
1208 {
1209 self.0.access_required(0, "TradesBatch", "trades")
1210 }
1211
1212 #[inline]
1214 pub fn batch_timestamp(&self) -> ::planus::Result<u64> {
1215 ::core::result::Result::Ok(
1216 self.0
1217 .access(1, "TradesBatch", "batch_timestamp")?
1218 .unwrap_or(0),
1219 )
1220 }
1221
1222 #[inline]
1224 pub fn batch_id(
1225 &self,
1226 ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>>
1227 {
1228 self.0.access(2, "TradesBatch", "batch_id")
1229 }
1230 }
1231
1232 impl<'a> ::core::fmt::Debug for TradesBatchRef<'a> {
1233 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1234 let mut f = f.debug_struct("TradesBatchRef");
1235 f.field("trades", &self.trades());
1236 f.field("batch_timestamp", &self.batch_timestamp());
1237 if let ::core::option::Option::Some(field_batch_id) =
1238 self.batch_id().transpose()
1239 {
1240 f.field("batch_id", &field_batch_id);
1241 }
1242 f.finish()
1243 }
1244 }
1245
1246 impl<'a> ::core::convert::TryFrom<TradesBatchRef<'a>> for TradesBatch {
1247 type Error = ::planus::Error;
1248
1249 #[allow(unreachable_code)]
1250 fn try_from(value: TradesBatchRef<'a>) -> ::planus::Result<Self> {
1251 ::core::result::Result::Ok(Self {
1252 trades: value.trades()?.to_vec_result()?,
1253 batch_timestamp: ::core::convert::TryInto::try_into(
1254 value.batch_timestamp()?,
1255 )?,
1256 batch_id: value.batch_id()?.map(::core::convert::Into::into),
1257 })
1258 }
1259 }
1260
1261 impl<'a> ::planus::TableRead<'a> for TradesBatchRef<'a> {
1262 #[inline]
1263 fn from_buffer(
1264 buffer: ::planus::SliceWithStartOffset<'a>,
1265 offset: usize,
1266 ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
1267 ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
1268 buffer, offset,
1269 )?))
1270 }
1271 }
1272
1273 impl<'a> ::planus::VectorReadInner<'a> for TradesBatchRef<'a> {
1274 type Error = ::planus::Error;
1275 const STRIDE: usize = 4;
1276
1277 unsafe fn from_buffer(
1278 buffer: ::planus::SliceWithStartOffset<'a>,
1279 offset: usize,
1280 ) -> ::planus::Result<Self> {
1281 ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
1282 error_kind.with_error_location(
1283 "[TradesBatchRef]",
1284 "get",
1285 buffer.offset_from_start,
1286 )
1287 })
1288 }
1289 }
1290
1291 unsafe impl ::planus::VectorWrite<::planus::Offset<TradesBatch>> for TradesBatch {
1295 type Value = ::planus::Offset<TradesBatch>;
1296 const STRIDE: usize = 4;
1297 #[inline]
1298 fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
1299 ::planus::WriteAs::prepare(self, builder)
1300 }
1301
1302 #[inline]
1303 unsafe fn write_values(
1304 values: &[::planus::Offset<TradesBatch>],
1305 bytes: *mut ::core::mem::MaybeUninit<u8>,
1306 buffer_position: u32,
1307 ) {
1308 let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
1309 for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
1310 ::planus::WriteAsPrimitive::write(
1311 v,
1312 ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
1313 buffer_position - (Self::STRIDE * i) as u32,
1314 );
1315 }
1316 }
1317 }
1318
1319 impl<'a> ::planus::ReadAsRoot<'a> for TradesBatchRef<'a> {
1320 fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
1321 ::planus::TableRead::from_buffer(
1322 ::planus::SliceWithStartOffset {
1323 buffer: slice,
1324 offset_from_start: 0,
1325 },
1326 0,
1327 )
1328 .map_err(|error_kind| {
1329 error_kind.with_error_location("[TradesBatchRef]", "read_as_root", 0)
1330 })
1331 }
1332 }
1333
1334 #[derive(
1339 Clone,
1340 Debug,
1341 PartialEq,
1342 PartialOrd,
1343 Eq,
1344 Ord,
1345 Hash,
1346 ::serde::Serialize,
1347 ::serde::Deserialize,
1348 )]
1349 pub struct TradeData {
1350 pub batch: ::planus::alloc::boxed::Box<self::TradesBatch>,
1352 pub metadata:
1354 ::core::option::Option<::planus::alloc::boxed::Box<self::TradeMetadata>>,
1355 }
1356
1357 #[allow(clippy::derivable_impls)]
1358 impl ::core::default::Default for TradeData {
1359 fn default() -> Self {
1360 Self {
1361 batch: ::core::default::Default::default(),
1362 metadata: ::core::default::Default::default(),
1363 }
1364 }
1365 }
1366
1367 impl TradeData {
1368 #[inline]
1370 pub const fn builder() -> TradeDataBuilder<()> {
1371 TradeDataBuilder(())
1372 }
1373
1374 #[allow(clippy::too_many_arguments)]
1375 pub fn create(
1376 builder: &mut ::planus::Builder,
1377 field_batch: impl ::planus::WriteAs<::planus::Offset<self::TradesBatch>>,
1378 field_metadata: impl ::planus::WriteAsOptional<
1379 ::planus::Offset<self::TradeMetadata>,
1380 >,
1381 ) -> ::planus::Offset<Self> {
1382 let prepared_batch = field_batch.prepare(builder);
1383 let prepared_metadata = field_metadata.prepare(builder);
1384
1385 let mut table_writer: ::planus::table_writer::TableWriter<8> =
1386 ::core::default::Default::default();
1387 table_writer.write_entry::<::planus::Offset<self::TradesBatch>>(0);
1388 if prepared_metadata.is_some() {
1389 table_writer.write_entry::<::planus::Offset<self::TradeMetadata>>(1);
1390 }
1391
1392 unsafe {
1393 table_writer.finish(builder, |object_writer| {
1394 object_writer.write::<_, _, 4>(&prepared_batch);
1395 if let ::core::option::Option::Some(prepared_metadata) =
1396 prepared_metadata
1397 {
1398 object_writer.write::<_, _, 4>(&prepared_metadata);
1399 }
1400 });
1401 }
1402 builder.current_offset()
1403 }
1404 }
1405
1406 impl ::planus::WriteAs<::planus::Offset<TradeData>> for TradeData {
1407 type Prepared = ::planus::Offset<Self>;
1408
1409 #[inline]
1410 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<TradeData> {
1411 ::planus::WriteAsOffset::prepare(self, builder)
1412 }
1413 }
1414
1415 impl ::planus::WriteAsOptional<::planus::Offset<TradeData>> for TradeData {
1416 type Prepared = ::planus::Offset<Self>;
1417
1418 #[inline]
1419 fn prepare(
1420 &self,
1421 builder: &mut ::planus::Builder,
1422 ) -> ::core::option::Option<::planus::Offset<TradeData>> {
1423 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1424 }
1425 }
1426
1427 impl ::planus::WriteAsOffset<TradeData> for TradeData {
1428 #[inline]
1429 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<TradeData> {
1430 TradeData::create(builder, &self.batch, &self.metadata)
1431 }
1432 }
1433
1434 #[derive(Debug)]
1438 #[must_use]
1439 pub struct TradeDataBuilder<State>(State);
1440
1441 impl TradeDataBuilder<()> {
1442 #[inline]
1444 #[allow(clippy::type_complexity)]
1445 pub const fn batch<T0>(self, value: T0) -> TradeDataBuilder<(T0,)>
1446 where
1447 T0: ::planus::WriteAs<::planus::Offset<self::TradesBatch>>,
1448 {
1449 TradeDataBuilder((value,))
1450 }
1451 }
1452
1453 impl<T0> TradeDataBuilder<(T0,)> {
1454 #[inline]
1456 #[allow(clippy::type_complexity)]
1457 pub fn metadata<T1>(self, value: T1) -> TradeDataBuilder<(T0, T1)>
1458 where
1459 T1: ::planus::WriteAsOptional<::planus::Offset<self::TradeMetadata>>,
1460 {
1461 let (v0,) = self.0;
1462 TradeDataBuilder((v0, value))
1463 }
1464
1465 #[inline]
1467 #[allow(clippy::type_complexity)]
1468 pub fn metadata_as_null(self) -> TradeDataBuilder<(T0, ())> {
1469 self.metadata(())
1470 }
1471 }
1472
1473 impl<T0, T1> TradeDataBuilder<(T0, T1)> {
1474 #[inline]
1476 pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset<TradeData>
1477 where
1478 Self: ::planus::WriteAsOffset<TradeData>,
1479 {
1480 ::planus::WriteAsOffset::prepare(&self, builder)
1481 }
1482 }
1483
1484 impl<
1485 T0: ::planus::WriteAs<::planus::Offset<self::TradesBatch>>,
1486 T1: ::planus::WriteAsOptional<::planus::Offset<self::TradeMetadata>>,
1487 > ::planus::WriteAs<::planus::Offset<TradeData>> for TradeDataBuilder<(T0, T1)>
1488 {
1489 type Prepared = ::planus::Offset<TradeData>;
1490
1491 #[inline]
1492 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<TradeData> {
1493 ::planus::WriteAsOffset::prepare(self, builder)
1494 }
1495 }
1496
1497 impl<
1498 T0: ::planus::WriteAs<::planus::Offset<self::TradesBatch>>,
1499 T1: ::planus::WriteAsOptional<::planus::Offset<self::TradeMetadata>>,
1500 > ::planus::WriteAsOptional<::planus::Offset<TradeData>>
1501 for TradeDataBuilder<(T0, T1)>
1502 {
1503 type Prepared = ::planus::Offset<TradeData>;
1504
1505 #[inline]
1506 fn prepare(
1507 &self,
1508 builder: &mut ::planus::Builder,
1509 ) -> ::core::option::Option<::planus::Offset<TradeData>> {
1510 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1511 }
1512 }
1513
1514 impl<
1515 T0: ::planus::WriteAs<::planus::Offset<self::TradesBatch>>,
1516 T1: ::planus::WriteAsOptional<::planus::Offset<self::TradeMetadata>>,
1517 > ::planus::WriteAsOffset<TradeData> for TradeDataBuilder<(T0, T1)>
1518 {
1519 #[inline]
1520 fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<TradeData> {
1521 let (v0, v1) = &self.0;
1522 TradeData::create(builder, v0, v1)
1523 }
1524 }
1525
1526 #[derive(Copy, Clone)]
1528 pub struct TradeDataRef<'a>(::planus::table_reader::Table<'a>);
1529
1530 impl<'a> TradeDataRef<'a> {
1531 #[inline]
1533 pub fn batch(&self) -> ::planus::Result<self::TradesBatchRef<'a>> {
1534 self.0.access_required(0, "TradeData", "batch")
1535 }
1536
1537 #[inline]
1539 pub fn metadata(
1540 &self,
1541 ) -> ::planus::Result<::core::option::Option<self::TradeMetadataRef<'a>>>
1542 {
1543 self.0.access(1, "TradeData", "metadata")
1544 }
1545 }
1546
1547 impl<'a> ::core::fmt::Debug for TradeDataRef<'a> {
1548 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1549 let mut f = f.debug_struct("TradeDataRef");
1550 f.field("batch", &self.batch());
1551 if let ::core::option::Option::Some(field_metadata) =
1552 self.metadata().transpose()
1553 {
1554 f.field("metadata", &field_metadata);
1555 }
1556 f.finish()
1557 }
1558 }
1559
1560 impl<'a> ::core::convert::TryFrom<TradeDataRef<'a>> for TradeData {
1561 type Error = ::planus::Error;
1562
1563 #[allow(unreachable_code)]
1564 fn try_from(value: TradeDataRef<'a>) -> ::planus::Result<Self> {
1565 ::core::result::Result::Ok(Self {
1566 batch: ::planus::alloc::boxed::Box::new(
1567 ::core::convert::TryInto::try_into(value.batch()?)?,
1568 ),
1569 metadata: if let ::core::option::Option::Some(metadata) =
1570 value.metadata()?
1571 {
1572 ::core::option::Option::Some(::planus::alloc::boxed::Box::new(
1573 ::core::convert::TryInto::try_into(metadata)?,
1574 ))
1575 } else {
1576 ::core::option::Option::None
1577 },
1578 })
1579 }
1580 }
1581
1582 impl<'a> ::planus::TableRead<'a> for TradeDataRef<'a> {
1583 #[inline]
1584 fn from_buffer(
1585 buffer: ::planus::SliceWithStartOffset<'a>,
1586 offset: usize,
1587 ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
1588 ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
1589 buffer, offset,
1590 )?))
1591 }
1592 }
1593
1594 impl<'a> ::planus::VectorReadInner<'a> for TradeDataRef<'a> {
1595 type Error = ::planus::Error;
1596 const STRIDE: usize = 4;
1597
1598 unsafe fn from_buffer(
1599 buffer: ::planus::SliceWithStartOffset<'a>,
1600 offset: usize,
1601 ) -> ::planus::Result<Self> {
1602 ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
1603 error_kind.with_error_location(
1604 "[TradeDataRef]",
1605 "get",
1606 buffer.offset_from_start,
1607 )
1608 })
1609 }
1610 }
1611
1612 unsafe impl ::planus::VectorWrite<::planus::Offset<TradeData>> for TradeData {
1616 type Value = ::planus::Offset<TradeData>;
1617 const STRIDE: usize = 4;
1618 #[inline]
1619 fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
1620 ::planus::WriteAs::prepare(self, builder)
1621 }
1622
1623 #[inline]
1624 unsafe fn write_values(
1625 values: &[::planus::Offset<TradeData>],
1626 bytes: *mut ::core::mem::MaybeUninit<u8>,
1627 buffer_position: u32,
1628 ) {
1629 let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
1630 for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
1631 ::planus::WriteAsPrimitive::write(
1632 v,
1633 ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
1634 buffer_position - (Self::STRIDE * i) as u32,
1635 );
1636 }
1637 }
1638 }
1639
1640 impl<'a> ::planus::ReadAsRoot<'a> for TradeDataRef<'a> {
1641 fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
1642 ::planus::TableRead::from_buffer(
1643 ::planus::SliceWithStartOffset {
1644 buffer: slice,
1645 offset_from_start: 0,
1646 },
1647 0,
1648 )
1649 .map_err(|error_kind| {
1650 error_kind.with_error_location("[TradeDataRef]", "read_as_root", 0)
1651 })
1652 }
1653 }
1654
1655 #[derive(
1660 Clone,
1661 Debug,
1662 PartialEq,
1663 PartialOrd,
1664 Eq,
1665 Ord,
1666 Hash,
1667 ::serde::Serialize,
1668 ::serde::Deserialize,
1669 )]
1670 pub struct TradeMetadata {
1671 pub file_version: u32,
1673 pub created_at: u64,
1675 pub exchange: ::planus::alloc::string::String,
1677 pub symbol: ::planus::alloc::string::String,
1679 pub date: ::planus::alloc::string::String,
1681 pub total_trades: u64,
1683 pub first_trade_time: u64,
1685 pub last_trade_time: u64,
1687 pub compression_level: u8,
1689 }
1690
1691 #[allow(clippy::derivable_impls)]
1692 impl ::core::default::Default for TradeMetadata {
1693 fn default() -> Self {
1694 Self {
1695 file_version: 1,
1696 created_at: 0,
1697 exchange: ::core::default::Default::default(),
1698 symbol: ::core::default::Default::default(),
1699 date: ::core::default::Default::default(),
1700 total_trades: 0,
1701 first_trade_time: 0,
1702 last_trade_time: 0,
1703 compression_level: 0,
1704 }
1705 }
1706 }
1707
1708 impl TradeMetadata {
1709 #[inline]
1711 pub const fn builder() -> TradeMetadataBuilder<()> {
1712 TradeMetadataBuilder(())
1713 }
1714
1715 #[allow(clippy::too_many_arguments)]
1716 pub fn create(
1717 builder: &mut ::planus::Builder,
1718 field_file_version: impl ::planus::WriteAsDefault<u32, u32>,
1719 field_created_at: impl ::planus::WriteAsDefault<u64, u64>,
1720 field_exchange: impl ::planus::WriteAs<::planus::Offset<str>>,
1721 field_symbol: impl ::planus::WriteAs<::planus::Offset<str>>,
1722 field_date: impl ::planus::WriteAs<::planus::Offset<str>>,
1723 field_total_trades: impl ::planus::WriteAsDefault<u64, u64>,
1724 field_first_trade_time: impl ::planus::WriteAsDefault<u64, u64>,
1725 field_last_trade_time: impl ::planus::WriteAsDefault<u64, u64>,
1726 field_compression_level: impl ::planus::WriteAsDefault<u8, u8>,
1727 ) -> ::planus::Offset<Self> {
1728 let prepared_file_version = field_file_version.prepare(builder, &1);
1729 let prepared_created_at = field_created_at.prepare(builder, &0);
1730 let prepared_exchange = field_exchange.prepare(builder);
1731 let prepared_symbol = field_symbol.prepare(builder);
1732 let prepared_date = field_date.prepare(builder);
1733 let prepared_total_trades = field_total_trades.prepare(builder, &0);
1734 let prepared_first_trade_time = field_first_trade_time.prepare(builder, &0);
1735 let prepared_last_trade_time = field_last_trade_time.prepare(builder, &0);
1736 let prepared_compression_level = field_compression_level.prepare(builder, &0);
1737
1738 let mut table_writer: ::planus::table_writer::TableWriter<22> =
1739 ::core::default::Default::default();
1740 if prepared_created_at.is_some() {
1741 table_writer.write_entry::<u64>(1);
1742 }
1743 if prepared_total_trades.is_some() {
1744 table_writer.write_entry::<u64>(5);
1745 }
1746 if prepared_first_trade_time.is_some() {
1747 table_writer.write_entry::<u64>(6);
1748 }
1749 if prepared_last_trade_time.is_some() {
1750 table_writer.write_entry::<u64>(7);
1751 }
1752 if prepared_file_version.is_some() {
1753 table_writer.write_entry::<u32>(0);
1754 }
1755 table_writer.write_entry::<::planus::Offset<str>>(2);
1756 table_writer.write_entry::<::planus::Offset<str>>(3);
1757 table_writer.write_entry::<::planus::Offset<str>>(4);
1758 if prepared_compression_level.is_some() {
1759 table_writer.write_entry::<u8>(8);
1760 }
1761
1762 unsafe {
1763 table_writer.finish(builder, |object_writer| {
1764 if let ::core::option::Option::Some(prepared_created_at) =
1765 prepared_created_at
1766 {
1767 object_writer.write::<_, _, 8>(&prepared_created_at);
1768 }
1769 if let ::core::option::Option::Some(prepared_total_trades) =
1770 prepared_total_trades
1771 {
1772 object_writer.write::<_, _, 8>(&prepared_total_trades);
1773 }
1774 if let ::core::option::Option::Some(prepared_first_trade_time) =
1775 prepared_first_trade_time
1776 {
1777 object_writer.write::<_, _, 8>(&prepared_first_trade_time);
1778 }
1779 if let ::core::option::Option::Some(prepared_last_trade_time) =
1780 prepared_last_trade_time
1781 {
1782 object_writer.write::<_, _, 8>(&prepared_last_trade_time);
1783 }
1784 if let ::core::option::Option::Some(prepared_file_version) =
1785 prepared_file_version
1786 {
1787 object_writer.write::<_, _, 4>(&prepared_file_version);
1788 }
1789 object_writer.write::<_, _, 4>(&prepared_exchange);
1790 object_writer.write::<_, _, 4>(&prepared_symbol);
1791 object_writer.write::<_, _, 4>(&prepared_date);
1792 if let ::core::option::Option::Some(prepared_compression_level) =
1793 prepared_compression_level
1794 {
1795 object_writer.write::<_, _, 1>(&prepared_compression_level);
1796 }
1797 });
1798 }
1799 builder.current_offset()
1800 }
1801 }
1802
1803 impl ::planus::WriteAs<::planus::Offset<TradeMetadata>> for TradeMetadata {
1804 type Prepared = ::planus::Offset<Self>;
1805
1806 #[inline]
1807 fn prepare(
1808 &self,
1809 builder: &mut ::planus::Builder,
1810 ) -> ::planus::Offset<TradeMetadata> {
1811 ::planus::WriteAsOffset::prepare(self, builder)
1812 }
1813 }
1814
1815 impl ::planus::WriteAsOptional<::planus::Offset<TradeMetadata>> for TradeMetadata {
1816 type Prepared = ::planus::Offset<Self>;
1817
1818 #[inline]
1819 fn prepare(
1820 &self,
1821 builder: &mut ::planus::Builder,
1822 ) -> ::core::option::Option<::planus::Offset<TradeMetadata>> {
1823 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1824 }
1825 }
1826
1827 impl ::planus::WriteAsOffset<TradeMetadata> for TradeMetadata {
1828 #[inline]
1829 fn prepare(
1830 &self,
1831 builder: &mut ::planus::Builder,
1832 ) -> ::planus::Offset<TradeMetadata> {
1833 TradeMetadata::create(
1834 builder,
1835 self.file_version,
1836 self.created_at,
1837 &self.exchange,
1838 &self.symbol,
1839 &self.date,
1840 self.total_trades,
1841 self.first_trade_time,
1842 self.last_trade_time,
1843 self.compression_level,
1844 )
1845 }
1846 }
1847
1848 #[derive(Debug)]
1852 #[must_use]
1853 pub struct TradeMetadataBuilder<State>(State);
1854
1855 impl TradeMetadataBuilder<()> {
1856 #[inline]
1858 #[allow(clippy::type_complexity)]
1859 pub const fn file_version<T0>(self, value: T0) -> TradeMetadataBuilder<(T0,)>
1860 where
1861 T0: ::planus::WriteAsDefault<u32, u32>,
1862 {
1863 TradeMetadataBuilder((value,))
1864 }
1865
1866 #[inline]
1868 #[allow(clippy::type_complexity)]
1869 pub const fn file_version_as_default(
1870 self,
1871 ) -> TradeMetadataBuilder<(::planus::DefaultValue,)> {
1872 self.file_version(::planus::DefaultValue)
1873 }
1874 }
1875
1876 impl<T0> TradeMetadataBuilder<(T0,)> {
1877 #[inline]
1879 #[allow(clippy::type_complexity)]
1880 pub fn created_at<T1>(self, value: T1) -> TradeMetadataBuilder<(T0, T1)>
1881 where
1882 T1: ::planus::WriteAsDefault<u64, u64>,
1883 {
1884 let (v0,) = self.0;
1885 TradeMetadataBuilder((v0, value))
1886 }
1887
1888 #[inline]
1890 #[allow(clippy::type_complexity)]
1891 pub fn created_at_as_default(
1892 self,
1893 ) -> TradeMetadataBuilder<(T0, ::planus::DefaultValue)> {
1894 self.created_at(::planus::DefaultValue)
1895 }
1896 }
1897
1898 impl<T0, T1> TradeMetadataBuilder<(T0, T1)> {
1899 #[inline]
1901 #[allow(clippy::type_complexity)]
1902 pub fn exchange<T2>(self, value: T2) -> TradeMetadataBuilder<(T0, T1, T2)>
1903 where
1904 T2: ::planus::WriteAs<::planus::Offset<str>>,
1905 {
1906 let (v0, v1) = self.0;
1907 TradeMetadataBuilder((v0, v1, value))
1908 }
1909 }
1910
1911 impl<T0, T1, T2> TradeMetadataBuilder<(T0, T1, T2)> {
1912 #[inline]
1914 #[allow(clippy::type_complexity)]
1915 pub fn symbol<T3>(self, value: T3) -> TradeMetadataBuilder<(T0, T1, T2, T3)>
1916 where
1917 T3: ::planus::WriteAs<::planus::Offset<str>>,
1918 {
1919 let (v0, v1, v2) = self.0;
1920 TradeMetadataBuilder((v0, v1, v2, value))
1921 }
1922 }
1923
1924 impl<T0, T1, T2, T3> TradeMetadataBuilder<(T0, T1, T2, T3)> {
1925 #[inline]
1927 #[allow(clippy::type_complexity)]
1928 pub fn date<T4>(self, value: T4) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4)>
1929 where
1930 T4: ::planus::WriteAs<::planus::Offset<str>>,
1931 {
1932 let (v0, v1, v2, v3) = self.0;
1933 TradeMetadataBuilder((v0, v1, v2, v3, value))
1934 }
1935 }
1936
1937 impl<T0, T1, T2, T3, T4> TradeMetadataBuilder<(T0, T1, T2, T3, T4)> {
1938 #[inline]
1940 #[allow(clippy::type_complexity)]
1941 pub fn total_trades<T5>(
1942 self,
1943 value: T5,
1944 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5)>
1945 where
1946 T5: ::planus::WriteAsDefault<u64, u64>,
1947 {
1948 let (v0, v1, v2, v3, v4) = self.0;
1949 TradeMetadataBuilder((v0, v1, v2, v3, v4, value))
1950 }
1951
1952 #[inline]
1954 #[allow(clippy::type_complexity)]
1955 pub fn total_trades_as_default(
1956 self,
1957 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, ::planus::DefaultValue)>
1958 {
1959 self.total_trades(::planus::DefaultValue)
1960 }
1961 }
1962
1963 impl<T0, T1, T2, T3, T4, T5> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5)> {
1964 #[inline]
1966 #[allow(clippy::type_complexity)]
1967 pub fn first_trade_time<T6>(
1968 self,
1969 value: T6,
1970 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6)>
1971 where
1972 T6: ::planus::WriteAsDefault<u64, u64>,
1973 {
1974 let (v0, v1, v2, v3, v4, v5) = self.0;
1975 TradeMetadataBuilder((v0, v1, v2, v3, v4, v5, value))
1976 }
1977
1978 #[inline]
1980 #[allow(clippy::type_complexity)]
1981 pub fn first_trade_time_as_default(
1982 self,
1983 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, ::planus::DefaultValue)>
1984 {
1985 self.first_trade_time(::planus::DefaultValue)
1986 }
1987 }
1988
1989 impl<T0, T1, T2, T3, T4, T5, T6> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6)> {
1990 #[inline]
1992 #[allow(clippy::type_complexity)]
1993 pub fn last_trade_time<T7>(
1994 self,
1995 value: T7,
1996 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)>
1997 where
1998 T7: ::planus::WriteAsDefault<u64, u64>,
1999 {
2000 let (v0, v1, v2, v3, v4, v5, v6) = self.0;
2001 TradeMetadataBuilder((v0, v1, v2, v3, v4, v5, v6, value))
2002 }
2003
2004 #[inline]
2006 #[allow(clippy::type_complexity)]
2007 pub fn last_trade_time_as_default(
2008 self,
2009 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, ::planus::DefaultValue)>
2010 {
2011 self.last_trade_time(::planus::DefaultValue)
2012 }
2013 }
2014
2015 impl<T0, T1, T2, T3, T4, T5, T6, T7> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> {
2016 #[inline]
2018 #[allow(clippy::type_complexity)]
2019 pub fn compression_level<T8>(
2020 self,
2021 value: T8,
2022 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
2023 where
2024 T8: ::planus::WriteAsDefault<u8, u8>,
2025 {
2026 let (v0, v1, v2, v3, v4, v5, v6, v7) = self.0;
2027 TradeMetadataBuilder((v0, v1, v2, v3, v4, v5, v6, v7, value))
2028 }
2029
2030 #[inline]
2032 #[allow(clippy::type_complexity)]
2033 pub fn compression_level_as_default(
2034 self,
2035 ) -> TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, ::planus::DefaultValue)>
2036 {
2037 self.compression_level(::planus::DefaultValue)
2038 }
2039 }
2040
2041 impl<T0, T1, T2, T3, T4, T5, T6, T7, T8>
2042 TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
2043 {
2044 #[inline]
2046 pub fn finish(
2047 self,
2048 builder: &mut ::planus::Builder,
2049 ) -> ::planus::Offset<TradeMetadata>
2050 where
2051 Self: ::planus::WriteAsOffset<TradeMetadata>,
2052 {
2053 ::planus::WriteAsOffset::prepare(&self, builder)
2054 }
2055 }
2056
2057 impl<
2058 T0: ::planus::WriteAsDefault<u32, u32>,
2059 T1: ::planus::WriteAsDefault<u64, u64>,
2060 T2: ::planus::WriteAs<::planus::Offset<str>>,
2061 T3: ::planus::WriteAs<::planus::Offset<str>>,
2062 T4: ::planus::WriteAs<::planus::Offset<str>>,
2063 T5: ::planus::WriteAsDefault<u64, u64>,
2064 T6: ::planus::WriteAsDefault<u64, u64>,
2065 T7: ::planus::WriteAsDefault<u64, u64>,
2066 T8: ::planus::WriteAsDefault<u8, u8>,
2067 > ::planus::WriteAs<::planus::Offset<TradeMetadata>>
2068 for TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
2069 {
2070 type Prepared = ::planus::Offset<TradeMetadata>;
2071
2072 #[inline]
2073 fn prepare(
2074 &self,
2075 builder: &mut ::planus::Builder,
2076 ) -> ::planus::Offset<TradeMetadata> {
2077 ::planus::WriteAsOffset::prepare(self, builder)
2078 }
2079 }
2080
2081 impl<
2082 T0: ::planus::WriteAsDefault<u32, u32>,
2083 T1: ::planus::WriteAsDefault<u64, u64>,
2084 T2: ::planus::WriteAs<::planus::Offset<str>>,
2085 T3: ::planus::WriteAs<::planus::Offset<str>>,
2086 T4: ::planus::WriteAs<::planus::Offset<str>>,
2087 T5: ::planus::WriteAsDefault<u64, u64>,
2088 T6: ::planus::WriteAsDefault<u64, u64>,
2089 T7: ::planus::WriteAsDefault<u64, u64>,
2090 T8: ::planus::WriteAsDefault<u8, u8>,
2091 > ::planus::WriteAsOptional<::planus::Offset<TradeMetadata>>
2092 for TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
2093 {
2094 type Prepared = ::planus::Offset<TradeMetadata>;
2095
2096 #[inline]
2097 fn prepare(
2098 &self,
2099 builder: &mut ::planus::Builder,
2100 ) -> ::core::option::Option<::planus::Offset<TradeMetadata>> {
2101 ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
2102 }
2103 }
2104
2105 impl<
2106 T0: ::planus::WriteAsDefault<u32, u32>,
2107 T1: ::planus::WriteAsDefault<u64, u64>,
2108 T2: ::planus::WriteAs<::planus::Offset<str>>,
2109 T3: ::planus::WriteAs<::planus::Offset<str>>,
2110 T4: ::planus::WriteAs<::planus::Offset<str>>,
2111 T5: ::planus::WriteAsDefault<u64, u64>,
2112 T6: ::planus::WriteAsDefault<u64, u64>,
2113 T7: ::planus::WriteAsDefault<u64, u64>,
2114 T8: ::planus::WriteAsDefault<u8, u8>,
2115 > ::planus::WriteAsOffset<TradeMetadata>
2116 for TradeMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
2117 {
2118 #[inline]
2119 fn prepare(
2120 &self,
2121 builder: &mut ::planus::Builder,
2122 ) -> ::planus::Offset<TradeMetadata> {
2123 let (v0, v1, v2, v3, v4, v5, v6, v7, v8) = &self.0;
2124 TradeMetadata::create(builder, v0, v1, v2, v3, v4, v5, v6, v7, v8)
2125 }
2126 }
2127
2128 #[derive(Copy, Clone)]
2130 pub struct TradeMetadataRef<'a>(::planus::table_reader::Table<'a>);
2131
2132 impl<'a> TradeMetadataRef<'a> {
2133 #[inline]
2135 pub fn file_version(&self) -> ::planus::Result<u32> {
2136 ::core::result::Result::Ok(
2137 self.0
2138 .access(0, "TradeMetadata", "file_version")?
2139 .unwrap_or(1),
2140 )
2141 }
2142
2143 #[inline]
2145 pub fn created_at(&self) -> ::planus::Result<u64> {
2146 ::core::result::Result::Ok(
2147 self.0
2148 .access(1, "TradeMetadata", "created_at")?
2149 .unwrap_or(0),
2150 )
2151 }
2152
2153 #[inline]
2155 pub fn exchange(&self) -> ::planus::Result<&'a ::core::primitive::str> {
2156 self.0.access_required(2, "TradeMetadata", "exchange")
2157 }
2158
2159 #[inline]
2161 pub fn symbol(&self) -> ::planus::Result<&'a ::core::primitive::str> {
2162 self.0.access_required(3, "TradeMetadata", "symbol")
2163 }
2164
2165 #[inline]
2167 pub fn date(&self) -> ::planus::Result<&'a ::core::primitive::str> {
2168 self.0.access_required(4, "TradeMetadata", "date")
2169 }
2170
2171 #[inline]
2173 pub fn total_trades(&self) -> ::planus::Result<u64> {
2174 ::core::result::Result::Ok(
2175 self.0
2176 .access(5, "TradeMetadata", "total_trades")?
2177 .unwrap_or(0),
2178 )
2179 }
2180
2181 #[inline]
2183 pub fn first_trade_time(&self) -> ::planus::Result<u64> {
2184 ::core::result::Result::Ok(
2185 self.0
2186 .access(6, "TradeMetadata", "first_trade_time")?
2187 .unwrap_or(0),
2188 )
2189 }
2190
2191 #[inline]
2193 pub fn last_trade_time(&self) -> ::planus::Result<u64> {
2194 ::core::result::Result::Ok(
2195 self.0
2196 .access(7, "TradeMetadata", "last_trade_time")?
2197 .unwrap_or(0),
2198 )
2199 }
2200
2201 #[inline]
2203 pub fn compression_level(&self) -> ::planus::Result<u8> {
2204 ::core::result::Result::Ok(
2205 self.0
2206 .access(8, "TradeMetadata", "compression_level")?
2207 .unwrap_or(0),
2208 )
2209 }
2210 }
2211
2212 impl<'a> ::core::fmt::Debug for TradeMetadataRef<'a> {
2213 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2214 let mut f = f.debug_struct("TradeMetadataRef");
2215 f.field("file_version", &self.file_version());
2216 f.field("created_at", &self.created_at());
2217 f.field("exchange", &self.exchange());
2218 f.field("symbol", &self.symbol());
2219 f.field("date", &self.date());
2220 f.field("total_trades", &self.total_trades());
2221 f.field("first_trade_time", &self.first_trade_time());
2222 f.field("last_trade_time", &self.last_trade_time());
2223 f.field("compression_level", &self.compression_level());
2224 f.finish()
2225 }
2226 }
2227
2228 impl<'a> ::core::convert::TryFrom<TradeMetadataRef<'a>> for TradeMetadata {
2229 type Error = ::planus::Error;
2230
2231 #[allow(unreachable_code)]
2232 fn try_from(value: TradeMetadataRef<'a>) -> ::planus::Result<Self> {
2233 ::core::result::Result::Ok(Self {
2234 file_version: ::core::convert::TryInto::try_into(value.file_version()?)?,
2235 created_at: ::core::convert::TryInto::try_into(value.created_at()?)?,
2236 exchange: ::core::convert::Into::into(value.exchange()?),
2237 symbol: ::core::convert::Into::into(value.symbol()?),
2238 date: ::core::convert::Into::into(value.date()?),
2239 total_trades: ::core::convert::TryInto::try_into(value.total_trades()?)?,
2240 first_trade_time: ::core::convert::TryInto::try_into(
2241 value.first_trade_time()?,
2242 )?,
2243 last_trade_time: ::core::convert::TryInto::try_into(
2244 value.last_trade_time()?,
2245 )?,
2246 compression_level: ::core::convert::TryInto::try_into(
2247 value.compression_level()?,
2248 )?,
2249 })
2250 }
2251 }
2252
2253 impl<'a> ::planus::TableRead<'a> for TradeMetadataRef<'a> {
2254 #[inline]
2255 fn from_buffer(
2256 buffer: ::planus::SliceWithStartOffset<'a>,
2257 offset: usize,
2258 ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
2259 ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
2260 buffer, offset,
2261 )?))
2262 }
2263 }
2264
2265 impl<'a> ::planus::VectorReadInner<'a> for TradeMetadataRef<'a> {
2266 type Error = ::planus::Error;
2267 const STRIDE: usize = 4;
2268
2269 unsafe fn from_buffer(
2270 buffer: ::planus::SliceWithStartOffset<'a>,
2271 offset: usize,
2272 ) -> ::planus::Result<Self> {
2273 ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
2274 error_kind.with_error_location(
2275 "[TradeMetadataRef]",
2276 "get",
2277 buffer.offset_from_start,
2278 )
2279 })
2280 }
2281 }
2282
2283 unsafe impl ::planus::VectorWrite<::planus::Offset<TradeMetadata>> for TradeMetadata {
2287 type Value = ::planus::Offset<TradeMetadata>;
2288 const STRIDE: usize = 4;
2289 #[inline]
2290 fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
2291 ::planus::WriteAs::prepare(self, builder)
2292 }
2293
2294 #[inline]
2295 unsafe fn write_values(
2296 values: &[::planus::Offset<TradeMetadata>],
2297 bytes: *mut ::core::mem::MaybeUninit<u8>,
2298 buffer_position: u32,
2299 ) {
2300 let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
2301 for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
2302 ::planus::WriteAsPrimitive::write(
2303 v,
2304 ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
2305 buffer_position - (Self::STRIDE * i) as u32,
2306 );
2307 }
2308 }
2309 }
2310
2311 impl<'a> ::planus::ReadAsRoot<'a> for TradeMetadataRef<'a> {
2312 fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
2313 ::planus::TableRead::from_buffer(
2314 ::planus::SliceWithStartOffset {
2315 buffer: slice,
2316 offset_from_start: 0,
2317 },
2318 0,
2319 )
2320 .map_err(|error_kind| {
2321 error_kind.with_error_location("[TradeMetadataRef]", "read_as_root", 0)
2322 })
2323 }
2324 }
2325 }
2326 }
2327}