rusty_bin/monitor/schema/generated/
orderbook_generated.rs

1pub use root::*;
2
3const _: () = ::planus::check_version_compatibility("planus-1.1.1");
4
5/// The root namespace
6///
7/// Generated from these locations:
8/// * File `schemas/orderbook.fbs`
9#[no_implicit_prelude]
10#[allow(dead_code, clippy::needless_lifetimes)]
11mod root {
12    /// The namespace `rusty_monitor`
13    ///
14    /// Generated from these locations:
15    /// * File `schemas/orderbook.fbs`
16    pub mod rusty_monitor {
17        /// The namespace `rusty_monitor.schema`
18        ///
19        /// Generated from these locations:
20        /// * File `schemas/orderbook.fbs`
21        pub mod schema {
22            /// The table `PriceLevel` in the namespace `rusty_monitor.schema`
23            ///
24            /// Generated from these locations:
25            /// * Table `PriceLevel` in the file `schemas/orderbook.fbs:7`
26            #[derive(
27                Clone,
28                Debug,
29                PartialEq,
30                PartialOrd,
31                Eq,
32                Ord,
33                Hash,
34                ::serde::Serialize,
35                ::serde::Deserialize,
36            )]
37            pub struct PriceLevel {
38                /// The field `price` in the table `PriceLevel`
39                pub price: ::planus::alloc::string::String,
40                /// The field `quantity` in the table `PriceLevel`
41                pub quantity: ::planus::alloc::string::String,
42                /// The field `order_count` in the table `PriceLevel`
43                pub order_count: u32,
44            }
45
46            #[allow(clippy::derivable_impls)]
47            impl ::core::default::Default for PriceLevel {
48                fn default() -> Self {
49                    Self {
50                        price: ::core::default::Default::default(),
51                        quantity: ::core::default::Default::default(),
52                        order_count: 0,
53                    }
54                }
55            }
56
57            impl PriceLevel {
58                /// Creates a [PriceLevelBuilder] for serializing an instance of this table.
59                #[inline]
60                pub const fn builder() -> PriceLevelBuilder<()> {
61                    PriceLevelBuilder(())
62                }
63
64                #[allow(clippy::too_many_arguments)]
65                pub fn create(
66                    builder: &mut ::planus::Builder,
67                    field_price: impl ::planus::WriteAs<::planus::Offset<str>>,
68                    field_quantity: impl ::planus::WriteAs<::planus::Offset<str>>,
69                    field_order_count: impl ::planus::WriteAsDefault<u32, u32>,
70                ) -> ::planus::Offset<Self> {
71                    let prepared_price = field_price.prepare(builder);
72                    let prepared_quantity = field_quantity.prepare(builder);
73                    let prepared_order_count = field_order_count.prepare(builder, &0);
74
75                    let mut table_writer: ::planus::table_writer::TableWriter<10> =
76                        ::core::default::Default::default();
77                    table_writer.write_entry::<::planus::Offset<str>>(0);
78                    table_writer.write_entry::<::planus::Offset<str>>(1);
79                    if prepared_order_count.is_some() {
80                        table_writer.write_entry::<u32>(2);
81                    }
82
83                    unsafe {
84                        table_writer.finish(builder, |object_writer| {
85                            object_writer.write::<_, _, 4>(&prepared_price);
86                            object_writer.write::<_, _, 4>(&prepared_quantity);
87                            if let ::core::option::Option::Some(prepared_order_count) =
88                                prepared_order_count
89                            {
90                                object_writer.write::<_, _, 4>(&prepared_order_count);
91                            }
92                        });
93                    }
94                    builder.current_offset()
95                }
96            }
97
98            impl ::planus::WriteAs<::planus::Offset<PriceLevel>> for PriceLevel {
99                type Prepared = ::planus::Offset<Self>;
100
101                #[inline]
102                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<PriceLevel> {
103                    ::planus::WriteAsOffset::prepare(self, builder)
104                }
105            }
106
107            impl ::planus::WriteAsOptional<::planus::Offset<PriceLevel>> for PriceLevel {
108                type Prepared = ::planus::Offset<Self>;
109
110                #[inline]
111                fn prepare(
112                    &self,
113                    builder: &mut ::planus::Builder,
114                ) -> ::core::option::Option<::planus::Offset<PriceLevel>> {
115                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
116                }
117            }
118
119            impl ::planus::WriteAsOffset<PriceLevel> for PriceLevel {
120                #[inline]
121                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<PriceLevel> {
122                    PriceLevel::create(builder, &self.price, &self.quantity, self.order_count)
123                }
124            }
125
126            /// Builder for serializing an instance of the [PriceLevel] type.
127            ///
128            /// Can be created using the [PriceLevel::builder] method.
129            #[derive(Debug)]
130            #[must_use]
131            pub struct PriceLevelBuilder<State>(State);
132
133            impl PriceLevelBuilder<()> {
134                /// Setter for the [`price` field](PriceLevel#structfield.price).
135                #[inline]
136                #[allow(clippy::type_complexity)]
137                pub const fn price<T0>(self, value: T0) -> PriceLevelBuilder<(T0,)>
138                where
139                    T0: ::planus::WriteAs<::planus::Offset<str>>,
140                {
141                    PriceLevelBuilder((value,))
142                }
143            }
144
145            impl<T0> PriceLevelBuilder<(T0,)> {
146                /// Setter for the [`quantity` field](PriceLevel#structfield.quantity).
147                #[inline]
148                #[allow(clippy::type_complexity)]
149                pub fn quantity<T1>(self, value: T1) -> PriceLevelBuilder<(T0, T1)>
150                where
151                    T1: ::planus::WriteAs<::planus::Offset<str>>,
152                {
153                    let (v0,) = self.0;
154                    PriceLevelBuilder((v0, value))
155                }
156            }
157
158            impl<T0, T1> PriceLevelBuilder<(T0, T1)> {
159                /// Setter for the [`order_count` field](PriceLevel#structfield.order_count).
160                #[inline]
161                #[allow(clippy::type_complexity)]
162                pub fn order_count<T2>(self, value: T2) -> PriceLevelBuilder<(T0, T1, T2)>
163                where
164                    T2: ::planus::WriteAsDefault<u32, u32>,
165                {
166                    let (v0, v1) = self.0;
167                    PriceLevelBuilder((v0, v1, value))
168                }
169
170                /// Sets the [`order_count` field](PriceLevel#structfield.order_count) to the default value.
171                #[inline]
172                #[allow(clippy::type_complexity)]
173                pub fn order_count_as_default(
174                    self,
175                ) -> PriceLevelBuilder<(T0, T1, ::planus::DefaultValue)> {
176                    self.order_count(::planus::DefaultValue)
177                }
178            }
179
180            impl<T0, T1, T2> PriceLevelBuilder<(T0, T1, T2)> {
181                /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [PriceLevel].
182                #[inline]
183                pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset<PriceLevel>
184                where
185                    Self: ::planus::WriteAsOffset<PriceLevel>,
186                {
187                    ::planus::WriteAsOffset::prepare(&self, builder)
188                }
189            }
190
191            impl<
192                T0: ::planus::WriteAs<::planus::Offset<str>>,
193                T1: ::planus::WriteAs<::planus::Offset<str>>,
194                T2: ::planus::WriteAsDefault<u32, u32>,
195            > ::planus::WriteAs<::planus::Offset<PriceLevel>> for PriceLevelBuilder<(T0, T1, T2)>
196            {
197                type Prepared = ::planus::Offset<PriceLevel>;
198
199                #[inline]
200                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<PriceLevel> {
201                    ::planus::WriteAsOffset::prepare(self, builder)
202                }
203            }
204
205            impl<
206                T0: ::planus::WriteAs<::planus::Offset<str>>,
207                T1: ::planus::WriteAs<::planus::Offset<str>>,
208                T2: ::planus::WriteAsDefault<u32, u32>,
209            > ::planus::WriteAsOptional<::planus::Offset<PriceLevel>>
210                for PriceLevelBuilder<(T0, T1, T2)>
211            {
212                type Prepared = ::planus::Offset<PriceLevel>;
213
214                #[inline]
215                fn prepare(
216                    &self,
217                    builder: &mut ::planus::Builder,
218                ) -> ::core::option::Option<::planus::Offset<PriceLevel>> {
219                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
220                }
221            }
222
223            impl<
224                T0: ::planus::WriteAs<::planus::Offset<str>>,
225                T1: ::planus::WriteAs<::planus::Offset<str>>,
226                T2: ::planus::WriteAsDefault<u32, u32>,
227            > ::planus::WriteAsOffset<PriceLevel> for PriceLevelBuilder<(T0, T1, T2)>
228            {
229                #[inline]
230                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<PriceLevel> {
231                    let (v0, v1, v2) = &self.0;
232                    PriceLevel::create(builder, v0, v1, v2)
233                }
234            }
235
236            /// Reference to a deserialized [PriceLevel].
237            #[derive(Copy, Clone)]
238            pub struct PriceLevelRef<'a>(::planus::table_reader::Table<'a>);
239
240            impl<'a> PriceLevelRef<'a> {
241                /// Getter for the [`price` field](PriceLevel#structfield.price).
242                #[inline]
243                pub fn price(&self) -> ::planus::Result<&'a ::core::primitive::str> {
244                    self.0.access_required(0, "PriceLevel", "price")
245                }
246
247                /// Getter for the [`quantity` field](PriceLevel#structfield.quantity).
248                #[inline]
249                pub fn quantity(&self) -> ::planus::Result<&'a ::core::primitive::str> {
250                    self.0.access_required(1, "PriceLevel", "quantity")
251                }
252
253                /// Getter for the [`order_count` field](PriceLevel#structfield.order_count).
254                #[inline]
255                pub fn order_count(&self) -> ::planus::Result<u32> {
256                    ::core::result::Result::Ok(
257                        self.0.access(2, "PriceLevel", "order_count")?.unwrap_or(0),
258                    )
259                }
260            }
261
262            impl<'a> ::core::fmt::Debug for PriceLevelRef<'a> {
263                fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
264                    let mut f = f.debug_struct("PriceLevelRef");
265                    f.field("price", &self.price());
266                    f.field("quantity", &self.quantity());
267                    f.field("order_count", &self.order_count());
268                    f.finish()
269                }
270            }
271
272            impl<'a> ::core::convert::TryFrom<PriceLevelRef<'a>> for PriceLevel {
273                type Error = ::planus::Error;
274
275                #[allow(unreachable_code)]
276                fn try_from(value: PriceLevelRef<'a>) -> ::planus::Result<Self> {
277                    ::core::result::Result::Ok(Self {
278                        price: ::core::convert::Into::into(value.price()?),
279                        quantity: ::core::convert::Into::into(value.quantity()?),
280                        order_count: ::core::convert::TryInto::try_into(value.order_count()?)?,
281                    })
282                }
283            }
284
285            impl<'a> ::planus::TableRead<'a> for PriceLevelRef<'a> {
286                #[inline]
287                fn from_buffer(
288                    buffer: ::planus::SliceWithStartOffset<'a>,
289                    offset: usize,
290                ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
291                    ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
292                        buffer, offset,
293                    )?))
294                }
295            }
296
297            impl<'a> ::planus::VectorReadInner<'a> for PriceLevelRef<'a> {
298                type Error = ::planus::Error;
299                const STRIDE: usize = 4;
300
301                unsafe fn from_buffer(
302                    buffer: ::planus::SliceWithStartOffset<'a>,
303                    offset: usize,
304                ) -> ::planus::Result<Self> {
305                    ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
306                        error_kind.with_error_location(
307                            "[PriceLevelRef]",
308                            "get",
309                            buffer.offset_from_start,
310                        )
311                    })
312                }
313            }
314
315            /// # Safety
316            /// The planus compiler generates implementations that initialize
317            /// the bytes in `write_values`.
318            unsafe impl ::planus::VectorWrite<::planus::Offset<PriceLevel>> for PriceLevel {
319                type Value = ::planus::Offset<PriceLevel>;
320                const STRIDE: usize = 4;
321                #[inline]
322                fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
323                    ::planus::WriteAs::prepare(self, builder)
324                }
325
326                #[inline]
327                unsafe fn write_values(
328                    values: &[::planus::Offset<PriceLevel>],
329                    bytes: *mut ::core::mem::MaybeUninit<u8>,
330                    buffer_position: u32,
331                ) {
332                    let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
333                    for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
334                        ::planus::WriteAsPrimitive::write(
335                            v,
336                            ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
337                            buffer_position - (Self::STRIDE * i) as u32,
338                        );
339                    }
340                }
341            }
342
343            impl<'a> ::planus::ReadAsRoot<'a> for PriceLevelRef<'a> {
344                fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
345                    ::planus::TableRead::from_buffer(
346                        ::planus::SliceWithStartOffset {
347                            buffer: slice,
348                            offset_from_start: 0,
349                        },
350                        0,
351                    )
352                    .map_err(|error_kind| {
353                        error_kind.with_error_location("[PriceLevelRef]", "read_as_root", 0)
354                    })
355                }
356            }
357
358            /// The table `OrderBook` in the namespace `rusty_monitor.schema`
359            ///
360            /// Generated from these locations:
361            /// * Table `OrderBook` in the file `schemas/orderbook.fbs:14`
362            #[derive(
363                Clone,
364                Debug,
365                PartialEq,
366                PartialOrd,
367                Eq,
368                Ord,
369                Hash,
370                ::serde::Serialize,
371                ::serde::Deserialize,
372            )]
373            pub struct OrderBook {
374                /// The field `timestamp_exchange` in the table `OrderBook`
375                pub timestamp_exchange: u64,
376                /// The field `timestamp_system` in the table `OrderBook`
377                pub timestamp_system: u64,
378                /// The field `symbol` in the table `OrderBook`
379                pub symbol: ::planus::alloc::string::String,
380                /// The field `exchange` in the table `OrderBook`
381                pub exchange: ::planus::alloc::string::String,
382                /// The field `bids` in the table `OrderBook`
383                pub bids: ::planus::alloc::vec::Vec<self::PriceLevel>,
384                /// The field `asks` in the table `OrderBook`
385                pub asks: ::planus::alloc::vec::Vec<self::PriceLevel>,
386                /// The field `sequence` in the table `OrderBook`
387                pub sequence: u64,
388                /// The field `last_update_id` in the table `OrderBook`
389                pub last_update_id: u64,
390                /// The field `is_snapshot` in the table `OrderBook`
391                pub is_snapshot: bool,
392                /// The field `depth` in the table `OrderBook`
393                pub depth: u32,
394                /// The field `checksum` in the table `OrderBook`
395                pub checksum: ::core::option::Option<::planus::alloc::string::String>,
396            }
397
398            #[allow(clippy::derivable_impls)]
399            impl ::core::default::Default for OrderBook {
400                fn default() -> Self {
401                    Self {
402                        timestamp_exchange: 0,
403                        timestamp_system: 0,
404                        symbol: ::core::default::Default::default(),
405                        exchange: ::core::default::Default::default(),
406                        bids: ::core::default::Default::default(),
407                        asks: ::core::default::Default::default(),
408                        sequence: 0,
409                        last_update_id: 0,
410                        is_snapshot: false,
411                        depth: 0,
412                        checksum: ::core::default::Default::default(),
413                    }
414                }
415            }
416
417            impl OrderBook {
418                /// Creates a [OrderBookBuilder] for serializing an instance of this table.
419                #[inline]
420                pub const fn builder() -> OrderBookBuilder<()> {
421                    OrderBookBuilder(())
422                }
423
424                #[allow(clippy::too_many_arguments)]
425                pub fn create(
426                    builder: &mut ::planus::Builder,
427                    field_timestamp_exchange: impl ::planus::WriteAsDefault<u64, u64>,
428                    field_timestamp_system: impl ::planus::WriteAsDefault<u64, u64>,
429                    field_symbol: impl ::planus::WriteAs<::planus::Offset<str>>,
430                    field_exchange: impl ::planus::WriteAs<::planus::Offset<str>>,
431                    field_bids: impl ::planus::WriteAs<
432                        ::planus::Offset<[::planus::Offset<self::PriceLevel>]>,
433                    >,
434                    field_asks: impl ::planus::WriteAs<
435                        ::planus::Offset<[::planus::Offset<self::PriceLevel>]>,
436                    >,
437                    field_sequence: impl ::planus::WriteAsDefault<u64, u64>,
438                    field_last_update_id: impl ::planus::WriteAsDefault<u64, u64>,
439                    field_is_snapshot: impl ::planus::WriteAsDefault<bool, bool>,
440                    field_depth: impl ::planus::WriteAsDefault<u32, u32>,
441                    field_checksum: impl ::planus::WriteAsOptional<
442                        ::planus::Offset<::core::primitive::str>,
443                    >,
444                ) -> ::planus::Offset<Self> {
445                    let prepared_timestamp_exchange = field_timestamp_exchange.prepare(builder, &0);
446                    let prepared_timestamp_system = field_timestamp_system.prepare(builder, &0);
447                    let prepared_symbol = field_symbol.prepare(builder);
448                    let prepared_exchange = field_exchange.prepare(builder);
449                    let prepared_bids = field_bids.prepare(builder);
450                    let prepared_asks = field_asks.prepare(builder);
451                    let prepared_sequence = field_sequence.prepare(builder, &0);
452                    let prepared_last_update_id = field_last_update_id.prepare(builder, &0);
453                    let prepared_is_snapshot = field_is_snapshot.prepare(builder, &false);
454                    let prepared_depth = field_depth.prepare(builder, &0);
455                    let prepared_checksum = field_checksum.prepare(builder);
456
457                    let mut table_writer: ::planus::table_writer::TableWriter<26> =
458                        ::core::default::Default::default();
459                    if prepared_timestamp_exchange.is_some() {
460                        table_writer.write_entry::<u64>(0);
461                    }
462                    if prepared_timestamp_system.is_some() {
463                        table_writer.write_entry::<u64>(1);
464                    }
465                    if prepared_sequence.is_some() {
466                        table_writer.write_entry::<u64>(6);
467                    }
468                    if prepared_last_update_id.is_some() {
469                        table_writer.write_entry::<u64>(7);
470                    }
471                    table_writer.write_entry::<::planus::Offset<str>>(2);
472                    table_writer.write_entry::<::planus::Offset<str>>(3);
473                    table_writer
474                        .write_entry::<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>(4);
475                    table_writer
476                        .write_entry::<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>(5);
477                    if prepared_depth.is_some() {
478                        table_writer.write_entry::<u32>(9);
479                    }
480                    if prepared_checksum.is_some() {
481                        table_writer.write_entry::<::planus::Offset<str>>(10);
482                    }
483                    if prepared_is_snapshot.is_some() {
484                        table_writer.write_entry::<bool>(8);
485                    }
486
487                    unsafe {
488                        table_writer.finish(builder, |object_writer| {
489                            if let ::core::option::Option::Some(prepared_timestamp_exchange) =
490                                prepared_timestamp_exchange
491                            {
492                                object_writer.write::<_, _, 8>(&prepared_timestamp_exchange);
493                            }
494                            if let ::core::option::Option::Some(prepared_timestamp_system) =
495                                prepared_timestamp_system
496                            {
497                                object_writer.write::<_, _, 8>(&prepared_timestamp_system);
498                            }
499                            if let ::core::option::Option::Some(prepared_sequence) =
500                                prepared_sequence
501                            {
502                                object_writer.write::<_, _, 8>(&prepared_sequence);
503                            }
504                            if let ::core::option::Option::Some(prepared_last_update_id) =
505                                prepared_last_update_id
506                            {
507                                object_writer.write::<_, _, 8>(&prepared_last_update_id);
508                            }
509                            object_writer.write::<_, _, 4>(&prepared_symbol);
510                            object_writer.write::<_, _, 4>(&prepared_exchange);
511                            object_writer.write::<_, _, 4>(&prepared_bids);
512                            object_writer.write::<_, _, 4>(&prepared_asks);
513                            if let ::core::option::Option::Some(prepared_depth) = prepared_depth {
514                                object_writer.write::<_, _, 4>(&prepared_depth);
515                            }
516                            if let ::core::option::Option::Some(prepared_checksum) =
517                                prepared_checksum
518                            {
519                                object_writer.write::<_, _, 4>(&prepared_checksum);
520                            }
521                            if let ::core::option::Option::Some(prepared_is_snapshot) =
522                                prepared_is_snapshot
523                            {
524                                object_writer.write::<_, _, 1>(&prepared_is_snapshot);
525                            }
526                        });
527                    }
528                    builder.current_offset()
529                }
530            }
531
532            impl ::planus::WriteAs<::planus::Offset<OrderBook>> for OrderBook {
533                type Prepared = ::planus::Offset<Self>;
534
535                #[inline]
536                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<OrderBook> {
537                    ::planus::WriteAsOffset::prepare(self, builder)
538                }
539            }
540
541            impl ::planus::WriteAsOptional<::planus::Offset<OrderBook>> for OrderBook {
542                type Prepared = ::planus::Offset<Self>;
543
544                #[inline]
545                fn prepare(
546                    &self,
547                    builder: &mut ::planus::Builder,
548                ) -> ::core::option::Option<::planus::Offset<OrderBook>> {
549                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
550                }
551            }
552
553            impl ::planus::WriteAsOffset<OrderBook> for OrderBook {
554                #[inline]
555                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<OrderBook> {
556                    OrderBook::create(
557                        builder,
558                        self.timestamp_exchange,
559                        self.timestamp_system,
560                        &self.symbol,
561                        &self.exchange,
562                        &self.bids,
563                        &self.asks,
564                        self.sequence,
565                        self.last_update_id,
566                        self.is_snapshot,
567                        self.depth,
568                        &self.checksum,
569                    )
570                }
571            }
572
573            /// Builder for serializing an instance of the [OrderBook] type.
574            ///
575            /// Can be created using the [OrderBook::builder] method.
576            #[derive(Debug)]
577            #[must_use]
578            pub struct OrderBookBuilder<State>(State);
579
580            impl OrderBookBuilder<()> {
581                /// Setter for the [`timestamp_exchange` field](OrderBook#structfield.timestamp_exchange).
582                #[inline]
583                #[allow(clippy::type_complexity)]
584                pub const fn timestamp_exchange<T0>(self, value: T0) -> OrderBookBuilder<(T0,)>
585                where
586                    T0: ::planus::WriteAsDefault<u64, u64>,
587                {
588                    OrderBookBuilder((value,))
589                }
590
591                /// Sets the [`timestamp_exchange` field](OrderBook#structfield.timestamp_exchange) to the default value.
592                #[inline]
593                #[allow(clippy::type_complexity)]
594                pub const fn timestamp_exchange_as_default(
595                    self,
596                ) -> OrderBookBuilder<(::planus::DefaultValue,)> {
597                    self.timestamp_exchange(::planus::DefaultValue)
598                }
599            }
600
601            impl<T0> OrderBookBuilder<(T0,)> {
602                /// Setter for the [`timestamp_system` field](OrderBook#structfield.timestamp_system).
603                #[inline]
604                #[allow(clippy::type_complexity)]
605                pub fn timestamp_system<T1>(self, value: T1) -> OrderBookBuilder<(T0, T1)>
606                where
607                    T1: ::planus::WriteAsDefault<u64, u64>,
608                {
609                    let (v0,) = self.0;
610                    OrderBookBuilder((v0, value))
611                }
612
613                /// Sets the [`timestamp_system` field](OrderBook#structfield.timestamp_system) to the default value.
614                #[inline]
615                #[allow(clippy::type_complexity)]
616                pub fn timestamp_system_as_default(
617                    self,
618                ) -> OrderBookBuilder<(T0, ::planus::DefaultValue)> {
619                    self.timestamp_system(::planus::DefaultValue)
620                }
621            }
622
623            impl<T0, T1> OrderBookBuilder<(T0, T1)> {
624                /// Setter for the [`symbol` field](OrderBook#structfield.symbol).
625                #[inline]
626                #[allow(clippy::type_complexity)]
627                pub fn symbol<T2>(self, value: T2) -> OrderBookBuilder<(T0, T1, T2)>
628                where
629                    T2: ::planus::WriteAs<::planus::Offset<str>>,
630                {
631                    let (v0, v1) = self.0;
632                    OrderBookBuilder((v0, v1, value))
633                }
634            }
635
636            impl<T0, T1, T2> OrderBookBuilder<(T0, T1, T2)> {
637                /// Setter for the [`exchange` field](OrderBook#structfield.exchange).
638                #[inline]
639                #[allow(clippy::type_complexity)]
640                pub fn exchange<T3>(self, value: T3) -> OrderBookBuilder<(T0, T1, T2, T3)>
641                where
642                    T3: ::planus::WriteAs<::planus::Offset<str>>,
643                {
644                    let (v0, v1, v2) = self.0;
645                    OrderBookBuilder((v0, v1, v2, value))
646                }
647            }
648
649            impl<T0, T1, T2, T3> OrderBookBuilder<(T0, T1, T2, T3)> {
650                /// Setter for the [`bids` field](OrderBook#structfield.bids).
651                #[inline]
652                #[allow(clippy::type_complexity)]
653                pub fn bids<T4>(self, value: T4) -> OrderBookBuilder<(T0, T1, T2, T3, T4)>
654                where
655                    T4: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
656                {
657                    let (v0, v1, v2, v3) = self.0;
658                    OrderBookBuilder((v0, v1, v2, v3, value))
659                }
660            }
661
662            impl<T0, T1, T2, T3, T4> OrderBookBuilder<(T0, T1, T2, T3, T4)> {
663                /// Setter for the [`asks` field](OrderBook#structfield.asks).
664                #[inline]
665                #[allow(clippy::type_complexity)]
666                pub fn asks<T5>(self, value: T5) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5)>
667                where
668                    T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
669                {
670                    let (v0, v1, v2, v3, v4) = self.0;
671                    OrderBookBuilder((v0, v1, v2, v3, v4, value))
672                }
673            }
674
675            impl<T0, T1, T2, T3, T4, T5> OrderBookBuilder<(T0, T1, T2, T3, T4, T5)> {
676                /// Setter for the [`sequence` field](OrderBook#structfield.sequence).
677                #[inline]
678                #[allow(clippy::type_complexity)]
679                pub fn sequence<T6>(
680                    self,
681                    value: T6,
682                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6)>
683                where
684                    T6: ::planus::WriteAsDefault<u64, u64>,
685                {
686                    let (v0, v1, v2, v3, v4, v5) = self.0;
687                    OrderBookBuilder((v0, v1, v2, v3, v4, v5, value))
688                }
689
690                /// Sets the [`sequence` field](OrderBook#structfield.sequence) to the default value.
691                #[inline]
692                #[allow(clippy::type_complexity)]
693                pub fn sequence_as_default(
694                    self,
695                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, ::planus::DefaultValue)>
696                {
697                    self.sequence(::planus::DefaultValue)
698                }
699            }
700
701            impl<T0, T1, T2, T3, T4, T5, T6> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6)> {
702                /// Setter for the [`last_update_id` field](OrderBook#structfield.last_update_id).
703                #[inline]
704                #[allow(clippy::type_complexity)]
705                pub fn last_update_id<T7>(
706                    self,
707                    value: T7,
708                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)>
709                where
710                    T7: ::planus::WriteAsDefault<u64, u64>,
711                {
712                    let (v0, v1, v2, v3, v4, v5, v6) = self.0;
713                    OrderBookBuilder((v0, v1, v2, v3, v4, v5, v6, value))
714                }
715
716                /// Sets the [`last_update_id` field](OrderBook#structfield.last_update_id) to the default value.
717                #[inline]
718                #[allow(clippy::type_complexity)]
719                pub fn last_update_id_as_default(
720                    self,
721                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, ::planus::DefaultValue)>
722                {
723                    self.last_update_id(::planus::DefaultValue)
724                }
725            }
726
727            impl<T0, T1, T2, T3, T4, T5, T6, T7> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> {
728                /// Setter for the [`is_snapshot` field](OrderBook#structfield.is_snapshot).
729                #[inline]
730                #[allow(clippy::type_complexity)]
731                pub fn is_snapshot<T8>(
732                    self,
733                    value: T8,
734                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
735                where
736                    T8: ::planus::WriteAsDefault<bool, bool>,
737                {
738                    let (v0, v1, v2, v3, v4, v5, v6, v7) = self.0;
739                    OrderBookBuilder((v0, v1, v2, v3, v4, v5, v6, v7, value))
740                }
741
742                /// Sets the [`is_snapshot` field](OrderBook#structfield.is_snapshot) to the default value.
743                #[inline]
744                #[allow(clippy::type_complexity)]
745                pub fn is_snapshot_as_default(
746                    self,
747                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, ::planus::DefaultValue)>
748                {
749                    self.is_snapshot(::planus::DefaultValue)
750                }
751            }
752
753            impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> {
754                /// Setter for the [`depth` field](OrderBook#structfield.depth).
755                #[inline]
756                #[allow(clippy::type_complexity)]
757                pub fn depth<T9>(
758                    self,
759                    value: T9,
760                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
761                where
762                    T9: ::planus::WriteAsDefault<u32, u32>,
763                {
764                    let (v0, v1, v2, v3, v4, v5, v6, v7, v8) = self.0;
765                    OrderBookBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, value))
766                }
767
768                /// Sets the [`depth` field](OrderBook#structfield.depth) to the default value.
769                #[inline]
770                #[allow(clippy::type_complexity)]
771                pub fn depth_as_default(
772                    self,
773                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, ::planus::DefaultValue)>
774                {
775                    self.depth(::planus::DefaultValue)
776                }
777            }
778
779            impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
780                OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
781            {
782                /// Setter for the [`checksum` field](OrderBook#structfield.checksum).
783                #[inline]
784                #[allow(clippy::type_complexity)]
785                pub fn checksum<T10>(
786                    self,
787                    value: T10,
788                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
789                where
790                    T10: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
791                {
792                    let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) = self.0;
793                    OrderBookBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, value))
794                }
795
796                /// Sets the [`checksum` field](OrderBook#structfield.checksum) to null.
797                #[inline]
798                #[allow(clippy::type_complexity)]
799                pub fn checksum_as_null(
800                    self,
801                ) -> OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, ())>
802                {
803                    self.checksum(())
804                }
805            }
806
807            impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
808                OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
809            {
810                /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [OrderBook].
811                #[inline]
812                pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::Offset<OrderBook>
813                where
814                    Self: ::planus::WriteAsOffset<OrderBook>,
815                {
816                    ::planus::WriteAsOffset::prepare(&self, builder)
817                }
818            }
819
820            impl<
821                T0: ::planus::WriteAsDefault<u64, u64>,
822                T1: ::planus::WriteAsDefault<u64, u64>,
823                T2: ::planus::WriteAs<::planus::Offset<str>>,
824                T3: ::planus::WriteAs<::planus::Offset<str>>,
825                T4: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
826                T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
827                T6: ::planus::WriteAsDefault<u64, u64>,
828                T7: ::planus::WriteAsDefault<u64, u64>,
829                T8: ::planus::WriteAsDefault<bool, bool>,
830                T9: ::planus::WriteAsDefault<u32, u32>,
831                T10: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
832            > ::planus::WriteAs<::planus::Offset<OrderBook>>
833                for OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
834            {
835                type Prepared = ::planus::Offset<OrderBook>;
836
837                #[inline]
838                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<OrderBook> {
839                    ::planus::WriteAsOffset::prepare(self, builder)
840                }
841            }
842
843            impl<
844                T0: ::planus::WriteAsDefault<u64, u64>,
845                T1: ::planus::WriteAsDefault<u64, u64>,
846                T2: ::planus::WriteAs<::planus::Offset<str>>,
847                T3: ::planus::WriteAs<::planus::Offset<str>>,
848                T4: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
849                T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
850                T6: ::planus::WriteAsDefault<u64, u64>,
851                T7: ::planus::WriteAsDefault<u64, u64>,
852                T8: ::planus::WriteAsDefault<bool, bool>,
853                T9: ::planus::WriteAsDefault<u32, u32>,
854                T10: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
855            > ::planus::WriteAsOptional<::planus::Offset<OrderBook>>
856                for OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
857            {
858                type Prepared = ::planus::Offset<OrderBook>;
859
860                #[inline]
861                fn prepare(
862                    &self,
863                    builder: &mut ::planus::Builder,
864                ) -> ::core::option::Option<::planus::Offset<OrderBook>> {
865                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
866                }
867            }
868
869            impl<
870                T0: ::planus::WriteAsDefault<u64, u64>,
871                T1: ::planus::WriteAsDefault<u64, u64>,
872                T2: ::planus::WriteAs<::planus::Offset<str>>,
873                T3: ::planus::WriteAs<::planus::Offset<str>>,
874                T4: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
875                T5: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::PriceLevel>]>>,
876                T6: ::planus::WriteAsDefault<u64, u64>,
877                T7: ::planus::WriteAsDefault<u64, u64>,
878                T8: ::planus::WriteAsDefault<bool, bool>,
879                T9: ::planus::WriteAsDefault<u32, u32>,
880                T10: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
881            > ::planus::WriteAsOffset<OrderBook>
882                for OrderBookBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
883            {
884                #[inline]
885                fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::Offset<OrderBook> {
886                    let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) = &self.0;
887                    OrderBook::create(builder, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
888                }
889            }
890
891            /// Reference to a deserialized [OrderBook].
892            #[derive(Copy, Clone)]
893            pub struct OrderBookRef<'a>(::planus::table_reader::Table<'a>);
894
895            impl<'a> OrderBookRef<'a> {
896                /// Getter for the [`timestamp_exchange` field](OrderBook#structfield.timestamp_exchange).
897                #[inline]
898                pub fn timestamp_exchange(&self) -> ::planus::Result<u64> {
899                    ::core::result::Result::Ok(
900                        self.0
901                            .access(0, "OrderBook", "timestamp_exchange")?
902                            .unwrap_or(0),
903                    )
904                }
905
906                /// Getter for the [`timestamp_system` field](OrderBook#structfield.timestamp_system).
907                #[inline]
908                pub fn timestamp_system(&self) -> ::planus::Result<u64> {
909                    ::core::result::Result::Ok(
910                        self.0
911                            .access(1, "OrderBook", "timestamp_system")?
912                            .unwrap_or(0),
913                    )
914                }
915
916                /// Getter for the [`symbol` field](OrderBook#structfield.symbol).
917                #[inline]
918                pub fn symbol(&self) -> ::planus::Result<&'a ::core::primitive::str> {
919                    self.0.access_required(2, "OrderBook", "symbol")
920                }
921
922                /// Getter for the [`exchange` field](OrderBook#structfield.exchange).
923                #[inline]
924                pub fn exchange(&self) -> ::planus::Result<&'a ::core::primitive::str> {
925                    self.0.access_required(3, "OrderBook", "exchange")
926                }
927
928                /// Getter for the [`bids` field](OrderBook#structfield.bids).
929                #[inline]
930                pub fn bids(
931                    &self,
932                ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result<self::PriceLevelRef<'a>>>>
933                {
934                    self.0.access_required(4, "OrderBook", "bids")
935                }
936
937                /// Getter for the [`asks` field](OrderBook#structfield.asks).
938                #[inline]
939                pub fn asks(
940                    &self,
941                ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result<self::PriceLevelRef<'a>>>>
942                {
943                    self.0.access_required(5, "OrderBook", "asks")
944                }
945
946                /// Getter for the [`sequence` field](OrderBook#structfield.sequence).
947                #[inline]
948                pub fn sequence(&self) -> ::planus::Result<u64> {
949                    ::core::result::Result::Ok(
950                        self.0.access(6, "OrderBook", "sequence")?.unwrap_or(0),
951                    )
952                }
953
954                /// Getter for the [`last_update_id` field](OrderBook#structfield.last_update_id).
955                #[inline]
956                pub fn last_update_id(&self) -> ::planus::Result<u64> {
957                    ::core::result::Result::Ok(
958                        self.0
959                            .access(7, "OrderBook", "last_update_id")?
960                            .unwrap_or(0),
961                    )
962                }
963
964                /// Getter for the [`is_snapshot` field](OrderBook#structfield.is_snapshot).
965                #[inline]
966                pub fn is_snapshot(&self) -> ::planus::Result<bool> {
967                    ::core::result::Result::Ok(
968                        self.0
969                            .access(8, "OrderBook", "is_snapshot")?
970                            .unwrap_or(false),
971                    )
972                }
973
974                /// Getter for the [`depth` field](OrderBook#structfield.depth).
975                #[inline]
976                pub fn depth(&self) -> ::planus::Result<u32> {
977                    ::core::result::Result::Ok(self.0.access(9, "OrderBook", "depth")?.unwrap_or(0))
978                }
979
980                /// Getter for the [`checksum` field](OrderBook#structfield.checksum).
981                #[inline]
982                pub fn checksum(
983                    &self,
984                ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>>
985                {
986                    self.0.access(10, "OrderBook", "checksum")
987                }
988            }
989
990            impl<'a> ::core::fmt::Debug for OrderBookRef<'a> {
991                fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
992                    let mut f = f.debug_struct("OrderBookRef");
993                    f.field("timestamp_exchange", &self.timestamp_exchange());
994                    f.field("timestamp_system", &self.timestamp_system());
995                    f.field("symbol", &self.symbol());
996                    f.field("exchange", &self.exchange());
997                    f.field("bids", &self.bids());
998                    f.field("asks", &self.asks());
999                    f.field("sequence", &self.sequence());
1000                    f.field("last_update_id", &self.last_update_id());
1001                    f.field("is_snapshot", &self.is_snapshot());
1002                    f.field("depth", &self.depth());
1003                    if let ::core::option::Option::Some(field_checksum) =
1004                        self.checksum().transpose()
1005                    {
1006                        f.field("checksum", &field_checksum);
1007                    }
1008                    f.finish()
1009                }
1010            }
1011
1012            impl<'a> ::core::convert::TryFrom<OrderBookRef<'a>> for OrderBook {
1013                type Error = ::planus::Error;
1014
1015                #[allow(unreachable_code)]
1016                fn try_from(value: OrderBookRef<'a>) -> ::planus::Result<Self> {
1017                    ::core::result::Result::Ok(Self {
1018                        timestamp_exchange: ::core::convert::TryInto::try_into(
1019                            value.timestamp_exchange()?,
1020                        )?,
1021                        timestamp_system: ::core::convert::TryInto::try_into(
1022                            value.timestamp_system()?,
1023                        )?,
1024                        symbol: ::core::convert::Into::into(value.symbol()?),
1025                        exchange: ::core::convert::Into::into(value.exchange()?),
1026                        bids: value.bids()?.to_vec_result()?,
1027                        asks: value.asks()?.to_vec_result()?,
1028                        sequence: ::core::convert::TryInto::try_into(value.sequence()?)?,
1029                        last_update_id: ::core::convert::TryInto::try_into(
1030                            value.last_update_id()?,
1031                        )?,
1032                        is_snapshot: ::core::convert::TryInto::try_into(value.is_snapshot()?)?,
1033                        depth: ::core::convert::TryInto::try_into(value.depth()?)?,
1034                        checksum: value.checksum()?.map(::core::convert::Into::into),
1035                    })
1036                }
1037            }
1038
1039            impl<'a> ::planus::TableRead<'a> for OrderBookRef<'a> {
1040                #[inline]
1041                fn from_buffer(
1042                    buffer: ::planus::SliceWithStartOffset<'a>,
1043                    offset: usize,
1044                ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
1045                    ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
1046                        buffer, offset,
1047                    )?))
1048                }
1049            }
1050
1051            impl<'a> ::planus::VectorReadInner<'a> for OrderBookRef<'a> {
1052                type Error = ::planus::Error;
1053                const STRIDE: usize = 4;
1054
1055                unsafe fn from_buffer(
1056                    buffer: ::planus::SliceWithStartOffset<'a>,
1057                    offset: usize,
1058                ) -> ::planus::Result<Self> {
1059                    ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
1060                        error_kind.with_error_location(
1061                            "[OrderBookRef]",
1062                            "get",
1063                            buffer.offset_from_start,
1064                        )
1065                    })
1066                }
1067            }
1068
1069            /// # Safety
1070            /// The planus compiler generates implementations that initialize
1071            /// the bytes in `write_values`.
1072            unsafe impl ::planus::VectorWrite<::planus::Offset<OrderBook>> for OrderBook {
1073                type Value = ::planus::Offset<OrderBook>;
1074                const STRIDE: usize = 4;
1075                #[inline]
1076                fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
1077                    ::planus::WriteAs::prepare(self, builder)
1078                }
1079
1080                #[inline]
1081                unsafe fn write_values(
1082                    values: &[::planus::Offset<OrderBook>],
1083                    bytes: *mut ::core::mem::MaybeUninit<u8>,
1084                    buffer_position: u32,
1085                ) {
1086                    let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
1087                    for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
1088                        ::planus::WriteAsPrimitive::write(
1089                            v,
1090                            ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
1091                            buffer_position - (Self::STRIDE * i) as u32,
1092                        );
1093                    }
1094                }
1095            }
1096
1097            impl<'a> ::planus::ReadAsRoot<'a> for OrderBookRef<'a> {
1098                fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
1099                    ::planus::TableRead::from_buffer(
1100                        ::planus::SliceWithStartOffset {
1101                            buffer: slice,
1102                            offset_from_start: 0,
1103                        },
1104                        0,
1105                    )
1106                    .map_err(|error_kind| {
1107                        error_kind.with_error_location("[OrderBookRef]", "read_as_root", 0)
1108                    })
1109                }
1110            }
1111
1112            /// The table `OrderBookBatch` in the namespace `rusty_monitor.schema`
1113            ///
1114            /// Generated from these locations:
1115            /// * Table `OrderBookBatch` in the file `schemas/orderbook.fbs:42`
1116            #[derive(
1117                Clone,
1118                Debug,
1119                PartialEq,
1120                PartialOrd,
1121                Eq,
1122                Ord,
1123                Hash,
1124                ::serde::Serialize,
1125                ::serde::Deserialize,
1126            )]
1127            pub struct OrderBookBatch {
1128                /// The field `orderbooks` in the table `OrderBookBatch`
1129                pub orderbooks: ::planus::alloc::vec::Vec<self::OrderBook>,
1130                /// The field `batch_timestamp` in the table `OrderBookBatch`
1131                pub batch_timestamp: u64,
1132                /// The field `batch_id` in the table `OrderBookBatch`
1133                pub batch_id: ::core::option::Option<::planus::alloc::string::String>,
1134            }
1135
1136            #[allow(clippy::derivable_impls)]
1137            impl ::core::default::Default for OrderBookBatch {
1138                fn default() -> Self {
1139                    Self {
1140                        orderbooks: ::core::default::Default::default(),
1141                        batch_timestamp: 0,
1142                        batch_id: ::core::default::Default::default(),
1143                    }
1144                }
1145            }
1146
1147            impl OrderBookBatch {
1148                /// Creates a [OrderBookBatchBuilder] for serializing an instance of this table.
1149                #[inline]
1150                pub const fn builder() -> OrderBookBatchBuilder<()> {
1151                    OrderBookBatchBuilder(())
1152                }
1153
1154                #[allow(clippy::too_many_arguments)]
1155                pub fn create(
1156                    builder: &mut ::planus::Builder,
1157                    field_orderbooks: impl ::planus::WriteAs<
1158                        ::planus::Offset<[::planus::Offset<self::OrderBook>]>,
1159                    >,
1160                    field_batch_timestamp: impl ::planus::WriteAsDefault<u64, u64>,
1161                    field_batch_id: impl ::planus::WriteAsOptional<
1162                        ::planus::Offset<::core::primitive::str>,
1163                    >,
1164                ) -> ::planus::Offset<Self> {
1165                    let prepared_orderbooks = field_orderbooks.prepare(builder);
1166                    let prepared_batch_timestamp = field_batch_timestamp.prepare(builder, &0);
1167                    let prepared_batch_id = field_batch_id.prepare(builder);
1168
1169                    let mut table_writer: ::planus::table_writer::TableWriter<10> =
1170                        ::core::default::Default::default();
1171                    if prepared_batch_timestamp.is_some() {
1172                        table_writer.write_entry::<u64>(1);
1173                    }
1174                    table_writer
1175                        .write_entry::<::planus::Offset<[::planus::Offset<self::OrderBook>]>>(0);
1176                    if prepared_batch_id.is_some() {
1177                        table_writer.write_entry::<::planus::Offset<str>>(2);
1178                    }
1179
1180                    unsafe {
1181                        table_writer.finish(builder, |object_writer| {
1182                            if let ::core::option::Option::Some(prepared_batch_timestamp) =
1183                                prepared_batch_timestamp
1184                            {
1185                                object_writer.write::<_, _, 8>(&prepared_batch_timestamp);
1186                            }
1187                            object_writer.write::<_, _, 4>(&prepared_orderbooks);
1188                            if let ::core::option::Option::Some(prepared_batch_id) =
1189                                prepared_batch_id
1190                            {
1191                                object_writer.write::<_, _, 4>(&prepared_batch_id);
1192                            }
1193                        });
1194                    }
1195                    builder.current_offset()
1196                }
1197            }
1198
1199            impl ::planus::WriteAs<::planus::Offset<OrderBookBatch>> for OrderBookBatch {
1200                type Prepared = ::planus::Offset<Self>;
1201
1202                #[inline]
1203                fn prepare(
1204                    &self,
1205                    builder: &mut ::planus::Builder,
1206                ) -> ::planus::Offset<OrderBookBatch> {
1207                    ::planus::WriteAsOffset::prepare(self, builder)
1208                }
1209            }
1210
1211            impl ::planus::WriteAsOptional<::planus::Offset<OrderBookBatch>> for OrderBookBatch {
1212                type Prepared = ::planus::Offset<Self>;
1213
1214                #[inline]
1215                fn prepare(
1216                    &self,
1217                    builder: &mut ::planus::Builder,
1218                ) -> ::core::option::Option<::planus::Offset<OrderBookBatch>> {
1219                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1220                }
1221            }
1222
1223            impl ::planus::WriteAsOffset<OrderBookBatch> for OrderBookBatch {
1224                #[inline]
1225                fn prepare(
1226                    &self,
1227                    builder: &mut ::planus::Builder,
1228                ) -> ::planus::Offset<OrderBookBatch> {
1229                    OrderBookBatch::create(
1230                        builder,
1231                        &self.orderbooks,
1232                        self.batch_timestamp,
1233                        &self.batch_id,
1234                    )
1235                }
1236            }
1237
1238            /// Builder for serializing an instance of the [OrderBookBatch] type.
1239            ///
1240            /// Can be created using the [OrderBookBatch::builder] method.
1241            #[derive(Debug)]
1242            #[must_use]
1243            pub struct OrderBookBatchBuilder<State>(State);
1244
1245            impl OrderBookBatchBuilder<()> {
1246                /// Setter for the [`orderbooks` field](OrderBookBatch#structfield.orderbooks).
1247                #[inline]
1248                #[allow(clippy::type_complexity)]
1249                pub const fn orderbooks<T0>(self, value: T0) -> OrderBookBatchBuilder<(T0,)>
1250                where
1251                    T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::OrderBook>]>>,
1252                {
1253                    OrderBookBatchBuilder((value,))
1254                }
1255            }
1256
1257            impl<T0> OrderBookBatchBuilder<(T0,)> {
1258                /// Setter for the [`batch_timestamp` field](OrderBookBatch#structfield.batch_timestamp).
1259                #[inline]
1260                #[allow(clippy::type_complexity)]
1261                pub fn batch_timestamp<T1>(self, value: T1) -> OrderBookBatchBuilder<(T0, T1)>
1262                where
1263                    T1: ::planus::WriteAsDefault<u64, u64>,
1264                {
1265                    let (v0,) = self.0;
1266                    OrderBookBatchBuilder((v0, value))
1267                }
1268
1269                /// Sets the [`batch_timestamp` field](OrderBookBatch#structfield.batch_timestamp) to the default value.
1270                #[inline]
1271                #[allow(clippy::type_complexity)]
1272                pub fn batch_timestamp_as_default(
1273                    self,
1274                ) -> OrderBookBatchBuilder<(T0, ::planus::DefaultValue)> {
1275                    self.batch_timestamp(::planus::DefaultValue)
1276                }
1277            }
1278
1279            impl<T0, T1> OrderBookBatchBuilder<(T0, T1)> {
1280                /// Setter for the [`batch_id` field](OrderBookBatch#structfield.batch_id).
1281                #[inline]
1282                #[allow(clippy::type_complexity)]
1283                pub fn batch_id<T2>(self, value: T2) -> OrderBookBatchBuilder<(T0, T1, T2)>
1284                where
1285                    T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1286                {
1287                    let (v0, v1) = self.0;
1288                    OrderBookBatchBuilder((v0, v1, value))
1289                }
1290
1291                /// Sets the [`batch_id` field](OrderBookBatch#structfield.batch_id) to null.
1292                #[inline]
1293                #[allow(clippy::type_complexity)]
1294                pub fn batch_id_as_null(self) -> OrderBookBatchBuilder<(T0, T1, ())> {
1295                    self.batch_id(())
1296                }
1297            }
1298
1299            impl<T0, T1, T2> OrderBookBatchBuilder<(T0, T1, T2)> {
1300                /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [OrderBookBatch].
1301                #[inline]
1302                pub fn finish(
1303                    self,
1304                    builder: &mut ::planus::Builder,
1305                ) -> ::planus::Offset<OrderBookBatch>
1306                where
1307                    Self: ::planus::WriteAsOffset<OrderBookBatch>,
1308                {
1309                    ::planus::WriteAsOffset::prepare(&self, builder)
1310                }
1311            }
1312
1313            impl<
1314                T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::OrderBook>]>>,
1315                T1: ::planus::WriteAsDefault<u64, u64>,
1316                T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1317            > ::planus::WriteAs<::planus::Offset<OrderBookBatch>>
1318                for OrderBookBatchBuilder<(T0, T1, T2)>
1319            {
1320                type Prepared = ::planus::Offset<OrderBookBatch>;
1321
1322                #[inline]
1323                fn prepare(
1324                    &self,
1325                    builder: &mut ::planus::Builder,
1326                ) -> ::planus::Offset<OrderBookBatch> {
1327                    ::planus::WriteAsOffset::prepare(self, builder)
1328                }
1329            }
1330
1331            impl<
1332                T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::OrderBook>]>>,
1333                T1: ::planus::WriteAsDefault<u64, u64>,
1334                T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1335            > ::planus::WriteAsOptional<::planus::Offset<OrderBookBatch>>
1336                for OrderBookBatchBuilder<(T0, T1, T2)>
1337            {
1338                type Prepared = ::planus::Offset<OrderBookBatch>;
1339
1340                #[inline]
1341                fn prepare(
1342                    &self,
1343                    builder: &mut ::planus::Builder,
1344                ) -> ::core::option::Option<::planus::Offset<OrderBookBatch>> {
1345                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1346                }
1347            }
1348
1349            impl<
1350                T0: ::planus::WriteAs<::planus::Offset<[::planus::Offset<self::OrderBook>]>>,
1351                T1: ::planus::WriteAsDefault<u64, u64>,
1352                T2: ::planus::WriteAsOptional<::planus::Offset<::core::primitive::str>>,
1353            > ::planus::WriteAsOffset<OrderBookBatch> for OrderBookBatchBuilder<(T0, T1, T2)>
1354            {
1355                #[inline]
1356                fn prepare(
1357                    &self,
1358                    builder: &mut ::planus::Builder,
1359                ) -> ::planus::Offset<OrderBookBatch> {
1360                    let (v0, v1, v2) = &self.0;
1361                    OrderBookBatch::create(builder, v0, v1, v2)
1362                }
1363            }
1364
1365            /// Reference to a deserialized [OrderBookBatch].
1366            #[derive(Copy, Clone)]
1367            pub struct OrderBookBatchRef<'a>(::planus::table_reader::Table<'a>);
1368
1369            impl<'a> OrderBookBatchRef<'a> {
1370                /// Getter for the [`orderbooks` field](OrderBookBatch#structfield.orderbooks).
1371                #[inline]
1372                pub fn orderbooks(
1373                    &self,
1374                ) -> ::planus::Result<::planus::Vector<'a, ::planus::Result<self::OrderBookRef<'a>>>>
1375                {
1376                    self.0.access_required(0, "OrderBookBatch", "orderbooks")
1377                }
1378
1379                /// Getter for the [`batch_timestamp` field](OrderBookBatch#structfield.batch_timestamp).
1380                #[inline]
1381                pub fn batch_timestamp(&self) -> ::planus::Result<u64> {
1382                    ::core::result::Result::Ok(
1383                        self.0
1384                            .access(1, "OrderBookBatch", "batch_timestamp")?
1385                            .unwrap_or(0),
1386                    )
1387                }
1388
1389                /// Getter for the [`batch_id` field](OrderBookBatch#structfield.batch_id).
1390                #[inline]
1391                pub fn batch_id(
1392                    &self,
1393                ) -> ::planus::Result<::core::option::Option<&'a ::core::primitive::str>>
1394                {
1395                    self.0.access(2, "OrderBookBatch", "batch_id")
1396                }
1397            }
1398
1399            impl<'a> ::core::fmt::Debug for OrderBookBatchRef<'a> {
1400                fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1401                    let mut f = f.debug_struct("OrderBookBatchRef");
1402                    f.field("orderbooks", &self.orderbooks());
1403                    f.field("batch_timestamp", &self.batch_timestamp());
1404                    if let ::core::option::Option::Some(field_batch_id) =
1405                        self.batch_id().transpose()
1406                    {
1407                        f.field("batch_id", &field_batch_id);
1408                    }
1409                    f.finish()
1410                }
1411            }
1412
1413            impl<'a> ::core::convert::TryFrom<OrderBookBatchRef<'a>> for OrderBookBatch {
1414                type Error = ::planus::Error;
1415
1416                #[allow(unreachable_code)]
1417                fn try_from(value: OrderBookBatchRef<'a>) -> ::planus::Result<Self> {
1418                    ::core::result::Result::Ok(Self {
1419                        orderbooks: value.orderbooks()?.to_vec_result()?,
1420                        batch_timestamp: ::core::convert::TryInto::try_into(
1421                            value.batch_timestamp()?,
1422                        )?,
1423                        batch_id: value.batch_id()?.map(::core::convert::Into::into),
1424                    })
1425                }
1426            }
1427
1428            impl<'a> ::planus::TableRead<'a> for OrderBookBatchRef<'a> {
1429                #[inline]
1430                fn from_buffer(
1431                    buffer: ::planus::SliceWithStartOffset<'a>,
1432                    offset: usize,
1433                ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
1434                    ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
1435                        buffer, offset,
1436                    )?))
1437                }
1438            }
1439
1440            impl<'a> ::planus::VectorReadInner<'a> for OrderBookBatchRef<'a> {
1441                type Error = ::planus::Error;
1442                const STRIDE: usize = 4;
1443
1444                unsafe fn from_buffer(
1445                    buffer: ::planus::SliceWithStartOffset<'a>,
1446                    offset: usize,
1447                ) -> ::planus::Result<Self> {
1448                    ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
1449                        error_kind.with_error_location(
1450                            "[OrderBookBatchRef]",
1451                            "get",
1452                            buffer.offset_from_start,
1453                        )
1454                    })
1455                }
1456            }
1457
1458            /// # Safety
1459            /// The planus compiler generates implementations that initialize
1460            /// the bytes in `write_values`.
1461            unsafe impl ::planus::VectorWrite<::planus::Offset<OrderBookBatch>> for OrderBookBatch {
1462                type Value = ::planus::Offset<OrderBookBatch>;
1463                const STRIDE: usize = 4;
1464                #[inline]
1465                fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
1466                    ::planus::WriteAs::prepare(self, builder)
1467                }
1468
1469                #[inline]
1470                unsafe fn write_values(
1471                    values: &[::planus::Offset<OrderBookBatch>],
1472                    bytes: *mut ::core::mem::MaybeUninit<u8>,
1473                    buffer_position: u32,
1474                ) {
1475                    let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
1476                    for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
1477                        ::planus::WriteAsPrimitive::write(
1478                            v,
1479                            ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
1480                            buffer_position - (Self::STRIDE * i) as u32,
1481                        );
1482                    }
1483                }
1484            }
1485
1486            impl<'a> ::planus::ReadAsRoot<'a> for OrderBookBatchRef<'a> {
1487                fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
1488                    ::planus::TableRead::from_buffer(
1489                        ::planus::SliceWithStartOffset {
1490                            buffer: slice,
1491                            offset_from_start: 0,
1492                        },
1493                        0,
1494                    )
1495                    .map_err(|error_kind| {
1496                        error_kind.with_error_location("[OrderBookBatchRef]", "read_as_root", 0)
1497                    })
1498                }
1499            }
1500
1501            /// The table `OrderBookData` in the namespace `rusty_monitor.schema`
1502            ///
1503            /// Generated from these locations:
1504            /// * Table `OrderBookData` in the file `schemas/orderbook.fbs:49`
1505            #[derive(
1506                Clone,
1507                Debug,
1508                PartialEq,
1509                PartialOrd,
1510                Eq,
1511                Ord,
1512                Hash,
1513                ::serde::Serialize,
1514                ::serde::Deserialize,
1515            )]
1516            pub struct OrderBookData {
1517                /// The field `batch` in the table `OrderBookData`
1518                pub batch: ::planus::alloc::boxed::Box<self::OrderBookBatch>,
1519                /// The field `metadata` in the table `OrderBookData`
1520                pub metadata:
1521                    ::core::option::Option<::planus::alloc::boxed::Box<self::OrderBookMetadata>>,
1522            }
1523
1524            #[allow(clippy::derivable_impls)]
1525            impl ::core::default::Default for OrderBookData {
1526                fn default() -> Self {
1527                    Self {
1528                        batch: ::core::default::Default::default(),
1529                        metadata: ::core::default::Default::default(),
1530                    }
1531                }
1532            }
1533
1534            impl OrderBookData {
1535                /// Creates a [OrderBookDataBuilder] for serializing an instance of this table.
1536                #[inline]
1537                pub const fn builder() -> OrderBookDataBuilder<()> {
1538                    OrderBookDataBuilder(())
1539                }
1540
1541                #[allow(clippy::too_many_arguments)]
1542                pub fn create(
1543                    builder: &mut ::planus::Builder,
1544                    field_batch: impl ::planus::WriteAs<::planus::Offset<self::OrderBookBatch>>,
1545                    field_metadata: impl ::planus::WriteAsOptional<
1546                        ::planus::Offset<self::OrderBookMetadata>,
1547                    >,
1548                ) -> ::planus::Offset<Self> {
1549                    let prepared_batch = field_batch.prepare(builder);
1550                    let prepared_metadata = field_metadata.prepare(builder);
1551
1552                    let mut table_writer: ::planus::table_writer::TableWriter<8> =
1553                        ::core::default::Default::default();
1554                    table_writer.write_entry::<::planus::Offset<self::OrderBookBatch>>(0);
1555                    if prepared_metadata.is_some() {
1556                        table_writer.write_entry::<::planus::Offset<self::OrderBookMetadata>>(1);
1557                    }
1558
1559                    unsafe {
1560                        table_writer.finish(builder, |object_writer| {
1561                            object_writer.write::<_, _, 4>(&prepared_batch);
1562                            if let ::core::option::Option::Some(prepared_metadata) =
1563                                prepared_metadata
1564                            {
1565                                object_writer.write::<_, _, 4>(&prepared_metadata);
1566                            }
1567                        });
1568                    }
1569                    builder.current_offset()
1570                }
1571            }
1572
1573            impl ::planus::WriteAs<::planus::Offset<OrderBookData>> for OrderBookData {
1574                type Prepared = ::planus::Offset<Self>;
1575
1576                #[inline]
1577                fn prepare(
1578                    &self,
1579                    builder: &mut ::planus::Builder,
1580                ) -> ::planus::Offset<OrderBookData> {
1581                    ::planus::WriteAsOffset::prepare(self, builder)
1582                }
1583            }
1584
1585            impl ::planus::WriteAsOptional<::planus::Offset<OrderBookData>> for OrderBookData {
1586                type Prepared = ::planus::Offset<Self>;
1587
1588                #[inline]
1589                fn prepare(
1590                    &self,
1591                    builder: &mut ::planus::Builder,
1592                ) -> ::core::option::Option<::planus::Offset<OrderBookData>> {
1593                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1594                }
1595            }
1596
1597            impl ::planus::WriteAsOffset<OrderBookData> for OrderBookData {
1598                #[inline]
1599                fn prepare(
1600                    &self,
1601                    builder: &mut ::planus::Builder,
1602                ) -> ::planus::Offset<OrderBookData> {
1603                    OrderBookData::create(builder, &self.batch, &self.metadata)
1604                }
1605            }
1606
1607            /// Builder for serializing an instance of the [OrderBookData] type.
1608            ///
1609            /// Can be created using the [OrderBookData::builder] method.
1610            #[derive(Debug)]
1611            #[must_use]
1612            pub struct OrderBookDataBuilder<State>(State);
1613
1614            impl OrderBookDataBuilder<()> {
1615                /// Setter for the [`batch` field](OrderBookData#structfield.batch).
1616                #[inline]
1617                #[allow(clippy::type_complexity)]
1618                pub const fn batch<T0>(self, value: T0) -> OrderBookDataBuilder<(T0,)>
1619                where
1620                    T0: ::planus::WriteAs<::planus::Offset<self::OrderBookBatch>>,
1621                {
1622                    OrderBookDataBuilder((value,))
1623                }
1624            }
1625
1626            impl<T0> OrderBookDataBuilder<(T0,)> {
1627                /// Setter for the [`metadata` field](OrderBookData#structfield.metadata).
1628                #[inline]
1629                #[allow(clippy::type_complexity)]
1630                pub fn metadata<T1>(self, value: T1) -> OrderBookDataBuilder<(T0, T1)>
1631                where
1632                    T1: ::planus::WriteAsOptional<::planus::Offset<self::OrderBookMetadata>>,
1633                {
1634                    let (v0,) = self.0;
1635                    OrderBookDataBuilder((v0, value))
1636                }
1637
1638                /// Sets the [`metadata` field](OrderBookData#structfield.metadata) to null.
1639                #[inline]
1640                #[allow(clippy::type_complexity)]
1641                pub fn metadata_as_null(self) -> OrderBookDataBuilder<(T0, ())> {
1642                    self.metadata(())
1643                }
1644            }
1645
1646            impl<T0, T1> OrderBookDataBuilder<(T0, T1)> {
1647                /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [OrderBookData].
1648                #[inline]
1649                pub fn finish(
1650                    self,
1651                    builder: &mut ::planus::Builder,
1652                ) -> ::planus::Offset<OrderBookData>
1653                where
1654                    Self: ::planus::WriteAsOffset<OrderBookData>,
1655                {
1656                    ::planus::WriteAsOffset::prepare(&self, builder)
1657                }
1658            }
1659
1660            impl<
1661                T0: ::planus::WriteAs<::planus::Offset<self::OrderBookBatch>>,
1662                T1: ::planus::WriteAsOptional<::planus::Offset<self::OrderBookMetadata>>,
1663            > ::planus::WriteAs<::planus::Offset<OrderBookData>>
1664                for OrderBookDataBuilder<(T0, T1)>
1665            {
1666                type Prepared = ::planus::Offset<OrderBookData>;
1667
1668                #[inline]
1669                fn prepare(
1670                    &self,
1671                    builder: &mut ::planus::Builder,
1672                ) -> ::planus::Offset<OrderBookData> {
1673                    ::planus::WriteAsOffset::prepare(self, builder)
1674                }
1675            }
1676
1677            impl<
1678                T0: ::planus::WriteAs<::planus::Offset<self::OrderBookBatch>>,
1679                T1: ::planus::WriteAsOptional<::planus::Offset<self::OrderBookMetadata>>,
1680            > ::planus::WriteAsOptional<::planus::Offset<OrderBookData>>
1681                for OrderBookDataBuilder<(T0, T1)>
1682            {
1683                type Prepared = ::planus::Offset<OrderBookData>;
1684
1685                #[inline]
1686                fn prepare(
1687                    &self,
1688                    builder: &mut ::planus::Builder,
1689                ) -> ::core::option::Option<::planus::Offset<OrderBookData>> {
1690                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
1691                }
1692            }
1693
1694            impl<
1695                T0: ::planus::WriteAs<::planus::Offset<self::OrderBookBatch>>,
1696                T1: ::planus::WriteAsOptional<::planus::Offset<self::OrderBookMetadata>>,
1697            > ::planus::WriteAsOffset<OrderBookData> for OrderBookDataBuilder<(T0, T1)>
1698            {
1699                #[inline]
1700                fn prepare(
1701                    &self,
1702                    builder: &mut ::planus::Builder,
1703                ) -> ::planus::Offset<OrderBookData> {
1704                    let (v0, v1) = &self.0;
1705                    OrderBookData::create(builder, v0, v1)
1706                }
1707            }
1708
1709            /// Reference to a deserialized [OrderBookData].
1710            #[derive(Copy, Clone)]
1711            pub struct OrderBookDataRef<'a>(::planus::table_reader::Table<'a>);
1712
1713            impl<'a> OrderBookDataRef<'a> {
1714                /// Getter for the [`batch` field](OrderBookData#structfield.batch).
1715                #[inline]
1716                pub fn batch(&self) -> ::planus::Result<self::OrderBookBatchRef<'a>> {
1717                    self.0.access_required(0, "OrderBookData", "batch")
1718                }
1719
1720                /// Getter for the [`metadata` field](OrderBookData#structfield.metadata).
1721                #[inline]
1722                pub fn metadata(
1723                    &self,
1724                ) -> ::planus::Result<::core::option::Option<self::OrderBookMetadataRef<'a>>>
1725                {
1726                    self.0.access(1, "OrderBookData", "metadata")
1727                }
1728            }
1729
1730            impl<'a> ::core::fmt::Debug for OrderBookDataRef<'a> {
1731                fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1732                    let mut f = f.debug_struct("OrderBookDataRef");
1733                    f.field("batch", &self.batch());
1734                    if let ::core::option::Option::Some(field_metadata) =
1735                        self.metadata().transpose()
1736                    {
1737                        f.field("metadata", &field_metadata);
1738                    }
1739                    f.finish()
1740                }
1741            }
1742
1743            impl<'a> ::core::convert::TryFrom<OrderBookDataRef<'a>> for OrderBookData {
1744                type Error = ::planus::Error;
1745
1746                #[allow(unreachable_code)]
1747                fn try_from(value: OrderBookDataRef<'a>) -> ::planus::Result<Self> {
1748                    ::core::result::Result::Ok(Self {
1749                        batch: ::planus::alloc::boxed::Box::new(
1750                            ::core::convert::TryInto::try_into(value.batch()?)?,
1751                        ),
1752                        metadata: if let ::core::option::Option::Some(metadata) =
1753                            value.metadata()?
1754                        {
1755                            ::core::option::Option::Some(::planus::alloc::boxed::Box::new(
1756                                ::core::convert::TryInto::try_into(metadata)?,
1757                            ))
1758                        } else {
1759                            ::core::option::Option::None
1760                        },
1761                    })
1762                }
1763            }
1764
1765            impl<'a> ::planus::TableRead<'a> for OrderBookDataRef<'a> {
1766                #[inline]
1767                fn from_buffer(
1768                    buffer: ::planus::SliceWithStartOffset<'a>,
1769                    offset: usize,
1770                ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
1771                    ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
1772                        buffer, offset,
1773                    )?))
1774                }
1775            }
1776
1777            impl<'a> ::planus::VectorReadInner<'a> for OrderBookDataRef<'a> {
1778                type Error = ::planus::Error;
1779                const STRIDE: usize = 4;
1780
1781                unsafe fn from_buffer(
1782                    buffer: ::planus::SliceWithStartOffset<'a>,
1783                    offset: usize,
1784                ) -> ::planus::Result<Self> {
1785                    ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
1786                        error_kind.with_error_location(
1787                            "[OrderBookDataRef]",
1788                            "get",
1789                            buffer.offset_from_start,
1790                        )
1791                    })
1792                }
1793            }
1794
1795            /// # Safety
1796            /// The planus compiler generates implementations that initialize
1797            /// the bytes in `write_values`.
1798            unsafe impl ::planus::VectorWrite<::planus::Offset<OrderBookData>> for OrderBookData {
1799                type Value = ::planus::Offset<OrderBookData>;
1800                const STRIDE: usize = 4;
1801                #[inline]
1802                fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
1803                    ::planus::WriteAs::prepare(self, builder)
1804                }
1805
1806                #[inline]
1807                unsafe fn write_values(
1808                    values: &[::planus::Offset<OrderBookData>],
1809                    bytes: *mut ::core::mem::MaybeUninit<u8>,
1810                    buffer_position: u32,
1811                ) {
1812                    let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
1813                    for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
1814                        ::planus::WriteAsPrimitive::write(
1815                            v,
1816                            ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
1817                            buffer_position - (Self::STRIDE * i) as u32,
1818                        );
1819                    }
1820                }
1821            }
1822
1823            impl<'a> ::planus::ReadAsRoot<'a> for OrderBookDataRef<'a> {
1824                fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
1825                    ::planus::TableRead::from_buffer(
1826                        ::planus::SliceWithStartOffset {
1827                            buffer: slice,
1828                            offset_from_start: 0,
1829                        },
1830                        0,
1831                    )
1832                    .map_err(|error_kind| {
1833                        error_kind.with_error_location("[OrderBookDataRef]", "read_as_root", 0)
1834                    })
1835                }
1836            }
1837
1838            /// The table `OrderBookMetadata` in the namespace `rusty_monitor.schema`
1839            ///
1840            /// Generated from these locations:
1841            /// * Table `OrderBookMetadata` in the file `schemas/orderbook.fbs:55`
1842            #[derive(
1843                Clone,
1844                Debug,
1845                PartialEq,
1846                PartialOrd,
1847                Eq,
1848                Ord,
1849                Hash,
1850                ::serde::Serialize,
1851                ::serde::Deserialize,
1852            )]
1853            pub struct OrderBookMetadata {
1854                /// The field `file_version` in the table `OrderBookMetadata`
1855                pub file_version: u32,
1856                /// The field `created_at` in the table `OrderBookMetadata`
1857                pub created_at: u64,
1858                /// The field `exchange` in the table `OrderBookMetadata`
1859                pub exchange: ::planus::alloc::string::String,
1860                /// The field `symbol` in the table `OrderBookMetadata`
1861                pub symbol: ::planus::alloc::string::String,
1862                /// The field `date` in the table `OrderBookMetadata`
1863                pub date: ::planus::alloc::string::String,
1864                /// The field `total_updates` in the table `OrderBookMetadata`
1865                pub total_updates: u64,
1866                /// The field `first_update_time` in the table `OrderBookMetadata`
1867                pub first_update_time: u64,
1868                /// The field `last_update_time` in the table `OrderBookMetadata`
1869                pub last_update_time: u64,
1870                /// The field `max_depth` in the table `OrderBookMetadata`
1871                pub max_depth: u32,
1872                /// The field `compression_level` in the table `OrderBookMetadata`
1873                pub compression_level: u8,
1874                /// The field `snapshot_count` in the table `OrderBookMetadata`
1875                pub snapshot_count: u64,
1876                /// The field `update_count` in the table `OrderBookMetadata`
1877                pub update_count: u64,
1878            }
1879
1880            #[allow(clippy::derivable_impls)]
1881            impl ::core::default::Default for OrderBookMetadata {
1882                fn default() -> Self {
1883                    Self {
1884                        file_version: 1,
1885                        created_at: 0,
1886                        exchange: ::core::default::Default::default(),
1887                        symbol: ::core::default::Default::default(),
1888                        date: ::core::default::Default::default(),
1889                        total_updates: 0,
1890                        first_update_time: 0,
1891                        last_update_time: 0,
1892                        max_depth: 0,
1893                        compression_level: 0,
1894                        snapshot_count: 0,
1895                        update_count: 0,
1896                    }
1897                }
1898            }
1899
1900            impl OrderBookMetadata {
1901                /// Creates a [OrderBookMetadataBuilder] for serializing an instance of this table.
1902                #[inline]
1903                pub const fn builder() -> OrderBookMetadataBuilder<()> {
1904                    OrderBookMetadataBuilder(())
1905                }
1906
1907                #[allow(clippy::too_many_arguments)]
1908                pub fn create(
1909                    builder: &mut ::planus::Builder,
1910                    field_file_version: impl ::planus::WriteAsDefault<u32, u32>,
1911                    field_created_at: impl ::planus::WriteAsDefault<u64, u64>,
1912                    field_exchange: impl ::planus::WriteAs<::planus::Offset<str>>,
1913                    field_symbol: impl ::planus::WriteAs<::planus::Offset<str>>,
1914                    field_date: impl ::planus::WriteAs<::planus::Offset<str>>,
1915                    field_total_updates: impl ::planus::WriteAsDefault<u64, u64>,
1916                    field_first_update_time: impl ::planus::WriteAsDefault<u64, u64>,
1917                    field_last_update_time: impl ::planus::WriteAsDefault<u64, u64>,
1918                    field_max_depth: impl ::planus::WriteAsDefault<u32, u32>,
1919                    field_compression_level: impl ::planus::WriteAsDefault<u8, u8>,
1920                    field_snapshot_count: impl ::planus::WriteAsDefault<u64, u64>,
1921                    field_update_count: impl ::planus::WriteAsDefault<u64, u64>,
1922                ) -> ::planus::Offset<Self> {
1923                    let prepared_file_version = field_file_version.prepare(builder, &1);
1924                    let prepared_created_at = field_created_at.prepare(builder, &0);
1925                    let prepared_exchange = field_exchange.prepare(builder);
1926                    let prepared_symbol = field_symbol.prepare(builder);
1927                    let prepared_date = field_date.prepare(builder);
1928                    let prepared_total_updates = field_total_updates.prepare(builder, &0);
1929                    let prepared_first_update_time = field_first_update_time.prepare(builder, &0);
1930                    let prepared_last_update_time = field_last_update_time.prepare(builder, &0);
1931                    let prepared_max_depth = field_max_depth.prepare(builder, &0);
1932                    let prepared_compression_level = field_compression_level.prepare(builder, &0);
1933                    let prepared_snapshot_count = field_snapshot_count.prepare(builder, &0);
1934                    let prepared_update_count = field_update_count.prepare(builder, &0);
1935
1936                    let mut table_writer: ::planus::table_writer::TableWriter<28> =
1937                        ::core::default::Default::default();
1938                    if prepared_created_at.is_some() {
1939                        table_writer.write_entry::<u64>(1);
1940                    }
1941                    if prepared_total_updates.is_some() {
1942                        table_writer.write_entry::<u64>(5);
1943                    }
1944                    if prepared_first_update_time.is_some() {
1945                        table_writer.write_entry::<u64>(6);
1946                    }
1947                    if prepared_last_update_time.is_some() {
1948                        table_writer.write_entry::<u64>(7);
1949                    }
1950                    if prepared_snapshot_count.is_some() {
1951                        table_writer.write_entry::<u64>(10);
1952                    }
1953                    if prepared_update_count.is_some() {
1954                        table_writer.write_entry::<u64>(11);
1955                    }
1956                    if prepared_file_version.is_some() {
1957                        table_writer.write_entry::<u32>(0);
1958                    }
1959                    table_writer.write_entry::<::planus::Offset<str>>(2);
1960                    table_writer.write_entry::<::planus::Offset<str>>(3);
1961                    table_writer.write_entry::<::planus::Offset<str>>(4);
1962                    if prepared_max_depth.is_some() {
1963                        table_writer.write_entry::<u32>(8);
1964                    }
1965                    if prepared_compression_level.is_some() {
1966                        table_writer.write_entry::<u8>(9);
1967                    }
1968
1969                    unsafe {
1970                        table_writer.finish(builder, |object_writer| {
1971                            if let ::core::option::Option::Some(prepared_created_at) =
1972                                prepared_created_at
1973                            {
1974                                object_writer.write::<_, _, 8>(&prepared_created_at);
1975                            }
1976                            if let ::core::option::Option::Some(prepared_total_updates) =
1977                                prepared_total_updates
1978                            {
1979                                object_writer.write::<_, _, 8>(&prepared_total_updates);
1980                            }
1981                            if let ::core::option::Option::Some(prepared_first_update_time) =
1982                                prepared_first_update_time
1983                            {
1984                                object_writer.write::<_, _, 8>(&prepared_first_update_time);
1985                            }
1986                            if let ::core::option::Option::Some(prepared_last_update_time) =
1987                                prepared_last_update_time
1988                            {
1989                                object_writer.write::<_, _, 8>(&prepared_last_update_time);
1990                            }
1991                            if let ::core::option::Option::Some(prepared_snapshot_count) =
1992                                prepared_snapshot_count
1993                            {
1994                                object_writer.write::<_, _, 8>(&prepared_snapshot_count);
1995                            }
1996                            if let ::core::option::Option::Some(prepared_update_count) =
1997                                prepared_update_count
1998                            {
1999                                object_writer.write::<_, _, 8>(&prepared_update_count);
2000                            }
2001                            if let ::core::option::Option::Some(prepared_file_version) =
2002                                prepared_file_version
2003                            {
2004                                object_writer.write::<_, _, 4>(&prepared_file_version);
2005                            }
2006                            object_writer.write::<_, _, 4>(&prepared_exchange);
2007                            object_writer.write::<_, _, 4>(&prepared_symbol);
2008                            object_writer.write::<_, _, 4>(&prepared_date);
2009                            if let ::core::option::Option::Some(prepared_max_depth) =
2010                                prepared_max_depth
2011                            {
2012                                object_writer.write::<_, _, 4>(&prepared_max_depth);
2013                            }
2014                            if let ::core::option::Option::Some(prepared_compression_level) =
2015                                prepared_compression_level
2016                            {
2017                                object_writer.write::<_, _, 1>(&prepared_compression_level);
2018                            }
2019                        });
2020                    }
2021                    builder.current_offset()
2022                }
2023            }
2024
2025            impl ::planus::WriteAs<::planus::Offset<OrderBookMetadata>> for OrderBookMetadata {
2026                type Prepared = ::planus::Offset<Self>;
2027
2028                #[inline]
2029                fn prepare(
2030                    &self,
2031                    builder: &mut ::planus::Builder,
2032                ) -> ::planus::Offset<OrderBookMetadata> {
2033                    ::planus::WriteAsOffset::prepare(self, builder)
2034                }
2035            }
2036
2037            impl ::planus::WriteAsOptional<::planus::Offset<OrderBookMetadata>> for OrderBookMetadata {
2038                type Prepared = ::planus::Offset<Self>;
2039
2040                #[inline]
2041                fn prepare(
2042                    &self,
2043                    builder: &mut ::planus::Builder,
2044                ) -> ::core::option::Option<::planus::Offset<OrderBookMetadata>> {
2045                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
2046                }
2047            }
2048
2049            impl ::planus::WriteAsOffset<OrderBookMetadata> for OrderBookMetadata {
2050                #[inline]
2051                fn prepare(
2052                    &self,
2053                    builder: &mut ::planus::Builder,
2054                ) -> ::planus::Offset<OrderBookMetadata> {
2055                    OrderBookMetadata::create(
2056                        builder,
2057                        self.file_version,
2058                        self.created_at,
2059                        &self.exchange,
2060                        &self.symbol,
2061                        &self.date,
2062                        self.total_updates,
2063                        self.first_update_time,
2064                        self.last_update_time,
2065                        self.max_depth,
2066                        self.compression_level,
2067                        self.snapshot_count,
2068                        self.update_count,
2069                    )
2070                }
2071            }
2072
2073            /// Builder for serializing an instance of the [OrderBookMetadata] type.
2074            ///
2075            /// Can be created using the [OrderBookMetadata::builder] method.
2076            #[derive(Debug)]
2077            #[must_use]
2078            pub struct OrderBookMetadataBuilder<State>(State);
2079
2080            impl OrderBookMetadataBuilder<()> {
2081                /// Setter for the [`file_version` field](OrderBookMetadata#structfield.file_version).
2082                #[inline]
2083                #[allow(clippy::type_complexity)]
2084                pub const fn file_version<T0>(self, value: T0) -> OrderBookMetadataBuilder<(T0,)>
2085                where
2086                    T0: ::planus::WriteAsDefault<u32, u32>,
2087                {
2088                    OrderBookMetadataBuilder((value,))
2089                }
2090
2091                /// Sets the [`file_version` field](OrderBookMetadata#structfield.file_version) to the default value.
2092                #[inline]
2093                #[allow(clippy::type_complexity)]
2094                pub const fn file_version_as_default(
2095                    self,
2096                ) -> OrderBookMetadataBuilder<(::planus::DefaultValue,)> {
2097                    self.file_version(::planus::DefaultValue)
2098                }
2099            }
2100
2101            impl<T0> OrderBookMetadataBuilder<(T0,)> {
2102                /// Setter for the [`created_at` field](OrderBookMetadata#structfield.created_at).
2103                #[inline]
2104                #[allow(clippy::type_complexity)]
2105                pub fn created_at<T1>(self, value: T1) -> OrderBookMetadataBuilder<(T0, T1)>
2106                where
2107                    T1: ::planus::WriteAsDefault<u64, u64>,
2108                {
2109                    let (v0,) = self.0;
2110                    OrderBookMetadataBuilder((v0, value))
2111                }
2112
2113                /// Sets the [`created_at` field](OrderBookMetadata#structfield.created_at) to the default value.
2114                #[inline]
2115                #[allow(clippy::type_complexity)]
2116                pub fn created_at_as_default(
2117                    self,
2118                ) -> OrderBookMetadataBuilder<(T0, ::planus::DefaultValue)> {
2119                    self.created_at(::planus::DefaultValue)
2120                }
2121            }
2122
2123            impl<T0, T1> OrderBookMetadataBuilder<(T0, T1)> {
2124                /// Setter for the [`exchange` field](OrderBookMetadata#structfield.exchange).
2125                #[inline]
2126                #[allow(clippy::type_complexity)]
2127                pub fn exchange<T2>(self, value: T2) -> OrderBookMetadataBuilder<(T0, T1, T2)>
2128                where
2129                    T2: ::planus::WriteAs<::planus::Offset<str>>,
2130                {
2131                    let (v0, v1) = self.0;
2132                    OrderBookMetadataBuilder((v0, v1, value))
2133                }
2134            }
2135
2136            impl<T0, T1, T2> OrderBookMetadataBuilder<(T0, T1, T2)> {
2137                /// Setter for the [`symbol` field](OrderBookMetadata#structfield.symbol).
2138                #[inline]
2139                #[allow(clippy::type_complexity)]
2140                pub fn symbol<T3>(self, value: T3) -> OrderBookMetadataBuilder<(T0, T1, T2, T3)>
2141                where
2142                    T3: ::planus::WriteAs<::planus::Offset<str>>,
2143                {
2144                    let (v0, v1, v2) = self.0;
2145                    OrderBookMetadataBuilder((v0, v1, v2, value))
2146                }
2147            }
2148
2149            impl<T0, T1, T2, T3> OrderBookMetadataBuilder<(T0, T1, T2, T3)> {
2150                /// Setter for the [`date` field](OrderBookMetadata#structfield.date).
2151                #[inline]
2152                #[allow(clippy::type_complexity)]
2153                pub fn date<T4>(self, value: T4) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4)>
2154                where
2155                    T4: ::planus::WriteAs<::planus::Offset<str>>,
2156                {
2157                    let (v0, v1, v2, v3) = self.0;
2158                    OrderBookMetadataBuilder((v0, v1, v2, v3, value))
2159                }
2160            }
2161
2162            impl<T0, T1, T2, T3, T4> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4)> {
2163                /// Setter for the [`total_updates` field](OrderBookMetadata#structfield.total_updates).
2164                #[inline]
2165                #[allow(clippy::type_complexity)]
2166                pub fn total_updates<T5>(
2167                    self,
2168                    value: T5,
2169                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5)>
2170                where
2171                    T5: ::planus::WriteAsDefault<u64, u64>,
2172                {
2173                    let (v0, v1, v2, v3, v4) = self.0;
2174                    OrderBookMetadataBuilder((v0, v1, v2, v3, v4, value))
2175                }
2176
2177                /// Sets the [`total_updates` field](OrderBookMetadata#structfield.total_updates) to the default value.
2178                #[inline]
2179                #[allow(clippy::type_complexity)]
2180                pub fn total_updates_as_default(
2181                    self,
2182                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, ::planus::DefaultValue)>
2183                {
2184                    self.total_updates(::planus::DefaultValue)
2185                }
2186            }
2187
2188            impl<T0, T1, T2, T3, T4, T5> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5)> {
2189                /// Setter for the [`first_update_time` field](OrderBookMetadata#structfield.first_update_time).
2190                #[inline]
2191                #[allow(clippy::type_complexity)]
2192                pub fn first_update_time<T6>(
2193                    self,
2194                    value: T6,
2195                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6)>
2196                where
2197                    T6: ::planus::WriteAsDefault<u64, u64>,
2198                {
2199                    let (v0, v1, v2, v3, v4, v5) = self.0;
2200                    OrderBookMetadataBuilder((v0, v1, v2, v3, v4, v5, value))
2201                }
2202
2203                /// Sets the [`first_update_time` field](OrderBookMetadata#structfield.first_update_time) to the default value.
2204                #[inline]
2205                #[allow(clippy::type_complexity)]
2206                pub fn first_update_time_as_default(
2207                    self,
2208                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, ::planus::DefaultValue)>
2209                {
2210                    self.first_update_time(::planus::DefaultValue)
2211                }
2212            }
2213
2214            impl<T0, T1, T2, T3, T4, T5, T6> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6)> {
2215                /// Setter for the [`last_update_time` field](OrderBookMetadata#structfield.last_update_time).
2216                #[inline]
2217                #[allow(clippy::type_complexity)]
2218                pub fn last_update_time<T7>(
2219                    self,
2220                    value: T7,
2221                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)>
2222                where
2223                    T7: ::planus::WriteAsDefault<u64, u64>,
2224                {
2225                    let (v0, v1, v2, v3, v4, v5, v6) = self.0;
2226                    OrderBookMetadataBuilder((v0, v1, v2, v3, v4, v5, v6, value))
2227                }
2228
2229                /// Sets the [`last_update_time` field](OrderBookMetadata#structfield.last_update_time) to the default value.
2230                #[inline]
2231                #[allow(clippy::type_complexity)]
2232                pub fn last_update_time_as_default(
2233                    self,
2234                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, ::planus::DefaultValue)>
2235                {
2236                    self.last_update_time(::planus::DefaultValue)
2237                }
2238            }
2239
2240            impl<T0, T1, T2, T3, T4, T5, T6, T7> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7)> {
2241                /// Setter for the [`max_depth` field](OrderBookMetadata#structfield.max_depth).
2242                #[inline]
2243                #[allow(clippy::type_complexity)]
2244                pub fn max_depth<T8>(
2245                    self,
2246                    value: T8,
2247                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
2248                where
2249                    T8: ::planus::WriteAsDefault<u32, u32>,
2250                {
2251                    let (v0, v1, v2, v3, v4, v5, v6, v7) = self.0;
2252                    OrderBookMetadataBuilder((v0, v1, v2, v3, v4, v5, v6, v7, value))
2253                }
2254
2255                /// Sets the [`max_depth` field](OrderBookMetadata#structfield.max_depth) to the default value.
2256                #[inline]
2257                #[allow(clippy::type_complexity)]
2258                pub fn max_depth_as_default(
2259                    self,
2260                ) -> OrderBookMetadataBuilder<(
2261                    T0,
2262                    T1,
2263                    T2,
2264                    T3,
2265                    T4,
2266                    T5,
2267                    T6,
2268                    T7,
2269                    ::planus::DefaultValue,
2270                )> {
2271                    self.max_depth(::planus::DefaultValue)
2272                }
2273            }
2274
2275            impl<T0, T1, T2, T3, T4, T5, T6, T7, T8>
2276                OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8)>
2277            {
2278                /// Setter for the [`compression_level` field](OrderBookMetadata#structfield.compression_level).
2279                #[inline]
2280                #[allow(clippy::type_complexity)]
2281                pub fn compression_level<T9>(
2282                    self,
2283                    value: T9,
2284                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
2285                where
2286                    T9: ::planus::WriteAsDefault<u8, u8>,
2287                {
2288                    let (v0, v1, v2, v3, v4, v5, v6, v7, v8) = self.0;
2289                    OrderBookMetadataBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, value))
2290                }
2291
2292                /// Sets the [`compression_level` field](OrderBookMetadata#structfield.compression_level) to the default value.
2293                #[inline]
2294                #[allow(clippy::type_complexity)]
2295                pub fn compression_level_as_default(
2296                    self,
2297                ) -> OrderBookMetadataBuilder<(
2298                    T0,
2299                    T1,
2300                    T2,
2301                    T3,
2302                    T4,
2303                    T5,
2304                    T6,
2305                    T7,
2306                    T8,
2307                    ::planus::DefaultValue,
2308                )> {
2309                    self.compression_level(::planus::DefaultValue)
2310                }
2311            }
2312
2313            impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
2314                OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>
2315            {
2316                /// Setter for the [`snapshot_count` field](OrderBookMetadata#structfield.snapshot_count).
2317                #[inline]
2318                #[allow(clippy::type_complexity)]
2319                pub fn snapshot_count<T10>(
2320                    self,
2321                    value: T10,
2322                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
2323                where
2324                    T10: ::planus::WriteAsDefault<u64, u64>,
2325                {
2326                    let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) = self.0;
2327                    OrderBookMetadataBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, value))
2328                }
2329
2330                /// Sets the [`snapshot_count` field](OrderBookMetadata#structfield.snapshot_count) to the default value.
2331                #[inline]
2332                #[allow(clippy::type_complexity)]
2333                pub fn snapshot_count_as_default(
2334                    self,
2335                ) -> OrderBookMetadataBuilder<(
2336                    T0,
2337                    T1,
2338                    T2,
2339                    T3,
2340                    T4,
2341                    T5,
2342                    T6,
2343                    T7,
2344                    T8,
2345                    T9,
2346                    ::planus::DefaultValue,
2347                )> {
2348                    self.snapshot_count(::planus::DefaultValue)
2349                }
2350            }
2351
2352            impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
2353                OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
2354            {
2355                /// Setter for the [`update_count` field](OrderBookMetadata#structfield.update_count).
2356                #[inline]
2357                #[allow(clippy::type_complexity)]
2358                pub fn update_count<T11>(
2359                    self,
2360                    value: T11,
2361                ) -> OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
2362                where
2363                    T11: ::planus::WriteAsDefault<u64, u64>,
2364                {
2365                    let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) = self.0;
2366                    OrderBookMetadataBuilder((v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, value))
2367                }
2368
2369                /// Sets the [`update_count` field](OrderBookMetadata#structfield.update_count) to the default value.
2370                #[inline]
2371                #[allow(clippy::type_complexity)]
2372                pub fn update_count_as_default(
2373                    self,
2374                ) -> OrderBookMetadataBuilder<(
2375                    T0,
2376                    T1,
2377                    T2,
2378                    T3,
2379                    T4,
2380                    T5,
2381                    T6,
2382                    T7,
2383                    T8,
2384                    T9,
2385                    T10,
2386                    ::planus::DefaultValue,
2387                )> {
2388                    self.update_count(::planus::DefaultValue)
2389                }
2390            }
2391
2392            impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
2393                OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
2394            {
2395                /// Finish writing the builder to get an [Offset](::planus::Offset) to a serialized [OrderBookMetadata].
2396                #[inline]
2397                pub fn finish(
2398                    self,
2399                    builder: &mut ::planus::Builder,
2400                ) -> ::planus::Offset<OrderBookMetadata>
2401                where
2402                    Self: ::planus::WriteAsOffset<OrderBookMetadata>,
2403                {
2404                    ::planus::WriteAsOffset::prepare(&self, builder)
2405                }
2406            }
2407
2408            impl<
2409                T0: ::planus::WriteAsDefault<u32, u32>,
2410                T1: ::planus::WriteAsDefault<u64, u64>,
2411                T2: ::planus::WriteAs<::planus::Offset<str>>,
2412                T3: ::planus::WriteAs<::planus::Offset<str>>,
2413                T4: ::planus::WriteAs<::planus::Offset<str>>,
2414                T5: ::planus::WriteAsDefault<u64, u64>,
2415                T6: ::planus::WriteAsDefault<u64, u64>,
2416                T7: ::planus::WriteAsDefault<u64, u64>,
2417                T8: ::planus::WriteAsDefault<u32, u32>,
2418                T9: ::planus::WriteAsDefault<u8, u8>,
2419                T10: ::planus::WriteAsDefault<u64, u64>,
2420                T11: ::planus::WriteAsDefault<u64, u64>,
2421            > ::planus::WriteAs<::planus::Offset<OrderBookMetadata>>
2422                for OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
2423            {
2424                type Prepared = ::planus::Offset<OrderBookMetadata>;
2425
2426                #[inline]
2427                fn prepare(
2428                    &self,
2429                    builder: &mut ::planus::Builder,
2430                ) -> ::planus::Offset<OrderBookMetadata> {
2431                    ::planus::WriteAsOffset::prepare(self, builder)
2432                }
2433            }
2434
2435            impl<
2436                T0: ::planus::WriteAsDefault<u32, u32>,
2437                T1: ::planus::WriteAsDefault<u64, u64>,
2438                T2: ::planus::WriteAs<::planus::Offset<str>>,
2439                T3: ::planus::WriteAs<::planus::Offset<str>>,
2440                T4: ::planus::WriteAs<::planus::Offset<str>>,
2441                T5: ::planus::WriteAsDefault<u64, u64>,
2442                T6: ::planus::WriteAsDefault<u64, u64>,
2443                T7: ::planus::WriteAsDefault<u64, u64>,
2444                T8: ::planus::WriteAsDefault<u32, u32>,
2445                T9: ::planus::WriteAsDefault<u8, u8>,
2446                T10: ::planus::WriteAsDefault<u64, u64>,
2447                T11: ::planus::WriteAsDefault<u64, u64>,
2448            > ::planus::WriteAsOptional<::planus::Offset<OrderBookMetadata>>
2449                for OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
2450            {
2451                type Prepared = ::planus::Offset<OrderBookMetadata>;
2452
2453                #[inline]
2454                fn prepare(
2455                    &self,
2456                    builder: &mut ::planus::Builder,
2457                ) -> ::core::option::Option<::planus::Offset<OrderBookMetadata>> {
2458                    ::core::option::Option::Some(::planus::WriteAsOffset::prepare(self, builder))
2459                }
2460            }
2461
2462            impl<
2463                T0: ::planus::WriteAsDefault<u32, u32>,
2464                T1: ::planus::WriteAsDefault<u64, u64>,
2465                T2: ::planus::WriteAs<::planus::Offset<str>>,
2466                T3: ::planus::WriteAs<::planus::Offset<str>>,
2467                T4: ::planus::WriteAs<::planus::Offset<str>>,
2468                T5: ::planus::WriteAsDefault<u64, u64>,
2469                T6: ::planus::WriteAsDefault<u64, u64>,
2470                T7: ::planus::WriteAsDefault<u64, u64>,
2471                T8: ::planus::WriteAsDefault<u32, u32>,
2472                T9: ::planus::WriteAsDefault<u8, u8>,
2473                T10: ::planus::WriteAsDefault<u64, u64>,
2474                T11: ::planus::WriteAsDefault<u64, u64>,
2475            > ::planus::WriteAsOffset<OrderBookMetadata>
2476                for OrderBookMetadataBuilder<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
2477            {
2478                #[inline]
2479                fn prepare(
2480                    &self,
2481                    builder: &mut ::planus::Builder,
2482                ) -> ::planus::Offset<OrderBookMetadata> {
2483                    let (v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) = &self.0;
2484                    OrderBookMetadata::create(
2485                        builder, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
2486                    )
2487                }
2488            }
2489
2490            /// Reference to a deserialized [OrderBookMetadata].
2491            #[derive(Copy, Clone)]
2492            pub struct OrderBookMetadataRef<'a>(::planus::table_reader::Table<'a>);
2493
2494            impl<'a> OrderBookMetadataRef<'a> {
2495                /// Getter for the [`file_version` field](OrderBookMetadata#structfield.file_version).
2496                #[inline]
2497                pub fn file_version(&self) -> ::planus::Result<u32> {
2498                    ::core::result::Result::Ok(
2499                        self.0
2500                            .access(0, "OrderBookMetadata", "file_version")?
2501                            .unwrap_or(1),
2502                    )
2503                }
2504
2505                /// Getter for the [`created_at` field](OrderBookMetadata#structfield.created_at).
2506                #[inline]
2507                pub fn created_at(&self) -> ::planus::Result<u64> {
2508                    ::core::result::Result::Ok(
2509                        self.0
2510                            .access(1, "OrderBookMetadata", "created_at")?
2511                            .unwrap_or(0),
2512                    )
2513                }
2514
2515                /// Getter for the [`exchange` field](OrderBookMetadata#structfield.exchange).
2516                #[inline]
2517                pub fn exchange(&self) -> ::planus::Result<&'a ::core::primitive::str> {
2518                    self.0.access_required(2, "OrderBookMetadata", "exchange")
2519                }
2520
2521                /// Getter for the [`symbol` field](OrderBookMetadata#structfield.symbol).
2522                #[inline]
2523                pub fn symbol(&self) -> ::planus::Result<&'a ::core::primitive::str> {
2524                    self.0.access_required(3, "OrderBookMetadata", "symbol")
2525                }
2526
2527                /// Getter for the [`date` field](OrderBookMetadata#structfield.date).
2528                #[inline]
2529                pub fn date(&self) -> ::planus::Result<&'a ::core::primitive::str> {
2530                    self.0.access_required(4, "OrderBookMetadata", "date")
2531                }
2532
2533                /// Getter for the [`total_updates` field](OrderBookMetadata#structfield.total_updates).
2534                #[inline]
2535                pub fn total_updates(&self) -> ::planus::Result<u64> {
2536                    ::core::result::Result::Ok(
2537                        self.0
2538                            .access(5, "OrderBookMetadata", "total_updates")?
2539                            .unwrap_or(0),
2540                    )
2541                }
2542
2543                /// Getter for the [`first_update_time` field](OrderBookMetadata#structfield.first_update_time).
2544                #[inline]
2545                pub fn first_update_time(&self) -> ::planus::Result<u64> {
2546                    ::core::result::Result::Ok(
2547                        self.0
2548                            .access(6, "OrderBookMetadata", "first_update_time")?
2549                            .unwrap_or(0),
2550                    )
2551                }
2552
2553                /// Getter for the [`last_update_time` field](OrderBookMetadata#structfield.last_update_time).
2554                #[inline]
2555                pub fn last_update_time(&self) -> ::planus::Result<u64> {
2556                    ::core::result::Result::Ok(
2557                        self.0
2558                            .access(7, "OrderBookMetadata", "last_update_time")?
2559                            .unwrap_or(0),
2560                    )
2561                }
2562
2563                /// Getter for the [`max_depth` field](OrderBookMetadata#structfield.max_depth).
2564                #[inline]
2565                pub fn max_depth(&self) -> ::planus::Result<u32> {
2566                    ::core::result::Result::Ok(
2567                        self.0
2568                            .access(8, "OrderBookMetadata", "max_depth")?
2569                            .unwrap_or(0),
2570                    )
2571                }
2572
2573                /// Getter for the [`compression_level` field](OrderBookMetadata#structfield.compression_level).
2574                #[inline]
2575                pub fn compression_level(&self) -> ::planus::Result<u8> {
2576                    ::core::result::Result::Ok(
2577                        self.0
2578                            .access(9, "OrderBookMetadata", "compression_level")?
2579                            .unwrap_or(0),
2580                    )
2581                }
2582
2583                /// Getter for the [`snapshot_count` field](OrderBookMetadata#structfield.snapshot_count).
2584                #[inline]
2585                pub fn snapshot_count(&self) -> ::planus::Result<u64> {
2586                    ::core::result::Result::Ok(
2587                        self.0
2588                            .access(10, "OrderBookMetadata", "snapshot_count")?
2589                            .unwrap_or(0),
2590                    )
2591                }
2592
2593                /// Getter for the [`update_count` field](OrderBookMetadata#structfield.update_count).
2594                #[inline]
2595                pub fn update_count(&self) -> ::planus::Result<u64> {
2596                    ::core::result::Result::Ok(
2597                        self.0
2598                            .access(11, "OrderBookMetadata", "update_count")?
2599                            .unwrap_or(0),
2600                    )
2601                }
2602            }
2603
2604            impl<'a> ::core::fmt::Debug for OrderBookMetadataRef<'a> {
2605                fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2606                    let mut f = f.debug_struct("OrderBookMetadataRef");
2607                    f.field("file_version", &self.file_version());
2608                    f.field("created_at", &self.created_at());
2609                    f.field("exchange", &self.exchange());
2610                    f.field("symbol", &self.symbol());
2611                    f.field("date", &self.date());
2612                    f.field("total_updates", &self.total_updates());
2613                    f.field("first_update_time", &self.first_update_time());
2614                    f.field("last_update_time", &self.last_update_time());
2615                    f.field("max_depth", &self.max_depth());
2616                    f.field("compression_level", &self.compression_level());
2617                    f.field("snapshot_count", &self.snapshot_count());
2618                    f.field("update_count", &self.update_count());
2619                    f.finish()
2620                }
2621            }
2622
2623            impl<'a> ::core::convert::TryFrom<OrderBookMetadataRef<'a>> for OrderBookMetadata {
2624                type Error = ::planus::Error;
2625
2626                #[allow(unreachable_code)]
2627                fn try_from(value: OrderBookMetadataRef<'a>) -> ::planus::Result<Self> {
2628                    ::core::result::Result::Ok(Self {
2629                        file_version: ::core::convert::TryInto::try_into(value.file_version()?)?,
2630                        created_at: ::core::convert::TryInto::try_into(value.created_at()?)?,
2631                        exchange: ::core::convert::Into::into(value.exchange()?),
2632                        symbol: ::core::convert::Into::into(value.symbol()?),
2633                        date: ::core::convert::Into::into(value.date()?),
2634                        total_updates: ::core::convert::TryInto::try_into(value.total_updates()?)?,
2635                        first_update_time: ::core::convert::TryInto::try_into(
2636                            value.first_update_time()?,
2637                        )?,
2638                        last_update_time: ::core::convert::TryInto::try_into(
2639                            value.last_update_time()?,
2640                        )?,
2641                        max_depth: ::core::convert::TryInto::try_into(value.max_depth()?)?,
2642                        compression_level: ::core::convert::TryInto::try_into(
2643                            value.compression_level()?,
2644                        )?,
2645                        snapshot_count: ::core::convert::TryInto::try_into(
2646                            value.snapshot_count()?,
2647                        )?,
2648                        update_count: ::core::convert::TryInto::try_into(value.update_count()?)?,
2649                    })
2650                }
2651            }
2652
2653            impl<'a> ::planus::TableRead<'a> for OrderBookMetadataRef<'a> {
2654                #[inline]
2655                fn from_buffer(
2656                    buffer: ::planus::SliceWithStartOffset<'a>,
2657                    offset: usize,
2658                ) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
2659                    ::core::result::Result::Ok(Self(::planus::table_reader::Table::from_buffer(
2660                        buffer, offset,
2661                    )?))
2662                }
2663            }
2664
2665            impl<'a> ::planus::VectorReadInner<'a> for OrderBookMetadataRef<'a> {
2666                type Error = ::planus::Error;
2667                const STRIDE: usize = 4;
2668
2669                unsafe fn from_buffer(
2670                    buffer: ::planus::SliceWithStartOffset<'a>,
2671                    offset: usize,
2672                ) -> ::planus::Result<Self> {
2673                    ::planus::TableRead::from_buffer(buffer, offset).map_err(|error_kind| {
2674                        error_kind.with_error_location(
2675                            "[OrderBookMetadataRef]",
2676                            "get",
2677                            buffer.offset_from_start,
2678                        )
2679                    })
2680                }
2681            }
2682
2683            /// # Safety
2684            /// The planus compiler generates implementations that initialize
2685            /// the bytes in `write_values`.
2686            unsafe impl ::planus::VectorWrite<::planus::Offset<OrderBookMetadata>> for OrderBookMetadata {
2687                type Value = ::planus::Offset<OrderBookMetadata>;
2688                const STRIDE: usize = 4;
2689                #[inline]
2690                fn prepare(&self, builder: &mut ::planus::Builder) -> Self::Value {
2691                    ::planus::WriteAs::prepare(self, builder)
2692                }
2693
2694                #[inline]
2695                unsafe fn write_values(
2696                    values: &[::planus::Offset<OrderBookMetadata>],
2697                    bytes: *mut ::core::mem::MaybeUninit<u8>,
2698                    buffer_position: u32,
2699                ) {
2700                    let bytes = bytes as *mut [::core::mem::MaybeUninit<u8>; 4];
2701                    for (i, v) in ::core::iter::Iterator::enumerate(values.iter()) {
2702                        ::planus::WriteAsPrimitive::write(
2703                            v,
2704                            ::planus::Cursor::new(unsafe { &mut *bytes.add(i) }),
2705                            buffer_position - (Self::STRIDE * i) as u32,
2706                        );
2707                    }
2708                }
2709            }
2710
2711            impl<'a> ::planus::ReadAsRoot<'a> for OrderBookMetadataRef<'a> {
2712                fn read_as_root(slice: &'a [u8]) -> ::planus::Result<Self> {
2713                    ::planus::TableRead::from_buffer(
2714                        ::planus::SliceWithStartOffset {
2715                            buffer: slice,
2716                            offset_from_start: 0,
2717                        },
2718                        0,
2719                    )
2720                    .map_err(|error_kind| {
2721                        error_kind.with_error_location("[OrderBookMetadataRef]", "read_as_root", 0)
2722                    })
2723                }
2724            }
2725        }
2726    }
2727}
rusty_bin/monitor/schema/generated/orderbook_generated.rs

rusty_bin/monitor/schema/generated/
orderbook_generated.rs
