vortex_flatbuffers/generated/
message.rs

1// automatically generated by the FlatBuffers compiler, do not modify
2// @generated
3extern crate alloc;
4
5use crate::array::*;
6use crate::dtype::*;
7
8#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
9pub const ENUM_MIN_MESSAGE_VERSION: u8 = 0;
10#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
11pub const ENUM_MAX_MESSAGE_VERSION: u8 = 0;
12#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
13#[allow(non_camel_case_types)]
14pub const ENUM_VALUES_MESSAGE_VERSION: [MessageVersion; 1] = [
15  MessageVersion::V0,
16];
17
18#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
19#[repr(transparent)]
20pub struct MessageVersion(pub u8);
21#[allow(non_upper_case_globals)]
22impl MessageVersion {
23  pub const V0: Self = Self(0);
24
25  pub const ENUM_MIN: u8 = 0;
26  pub const ENUM_MAX: u8 = 0;
27  pub const ENUM_VALUES: &'static [Self] = &[
28    Self::V0,
29  ];
30  /// Returns the variant's name or "" if unknown.
31  pub fn variant_name(self) -> Option<&'static str> {
32    match self {
33      Self::V0 => Some("V0"),
34      _ => None,
35    }
36  }
37}
38impl ::core::fmt::Debug for MessageVersion {
39  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
40    if let Some(name) = self.variant_name() {
41      f.write_str(name)
42    } else {
43      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
44    }
45  }
46}
47impl<'a> ::flatbuffers::Follow<'a> for MessageVersion {
48  type Inner = Self;
49  #[inline]
50  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
51    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
52    Self(b)
53  }
54}
55
56impl ::flatbuffers::Push for MessageVersion {
57    type Output = MessageVersion;
58    #[inline]
59    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
60        unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
61    }
62}
63
64impl ::flatbuffers::EndianScalar for MessageVersion {
65  type Scalar = u8;
66  #[inline]
67  fn to_little_endian(self) -> u8 {
68    self.0.to_le()
69  }
70  #[inline]
71  #[allow(clippy::wrong_self_convention)]
72  fn from_little_endian(v: u8) -> Self {
73    let b = u8::from_le(v);
74    Self(b)
75  }
76}
77
78impl<'a> ::flatbuffers::Verifiable for MessageVersion {
79  #[inline]
80  fn run_verifier(
81    v: &mut ::flatbuffers::Verifier, pos: usize
82  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
83    u8::run_verifier(v, pos)
84  }
85}
86
87impl ::flatbuffers::SimpleToVerifyInSlice for MessageVersion {}
88#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
89pub const ENUM_MIN_MESSAGE_HEADER: u8 = 0;
90#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
91pub const ENUM_MAX_MESSAGE_HEADER: u8 = 3;
92#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
93#[allow(non_camel_case_types)]
94pub const ENUM_VALUES_MESSAGE_HEADER: [MessageHeader; 4] = [
95  MessageHeader::NONE,
96  MessageHeader::ArrayMessage,
97  MessageHeader::BufferMessage,
98  MessageHeader::DTypeMessage,
99];
100
101#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
102#[repr(transparent)]
103pub struct MessageHeader(pub u8);
104#[allow(non_upper_case_globals)]
105impl MessageHeader {
106  pub const NONE: Self = Self(0);
107  pub const ArrayMessage: Self = Self(1);
108  pub const BufferMessage: Self = Self(2);
109  pub const DTypeMessage: Self = Self(3);
110
111  pub const ENUM_MIN: u8 = 0;
112  pub const ENUM_MAX: u8 = 3;
113  pub const ENUM_VALUES: &'static [Self] = &[
114    Self::NONE,
115    Self::ArrayMessage,
116    Self::BufferMessage,
117    Self::DTypeMessage,
118  ];
119  /// Returns the variant's name or "" if unknown.
120  pub fn variant_name(self) -> Option<&'static str> {
121    match self {
122      Self::NONE => Some("NONE"),
123      Self::ArrayMessage => Some("ArrayMessage"),
124      Self::BufferMessage => Some("BufferMessage"),
125      Self::DTypeMessage => Some("DTypeMessage"),
126      _ => None,
127    }
128  }
129}
130impl ::core::fmt::Debug for MessageHeader {
131  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
132    if let Some(name) = self.variant_name() {
133      f.write_str(name)
134    } else {
135      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
136    }
137  }
138}
139impl<'a> ::flatbuffers::Follow<'a> for MessageHeader {
140  type Inner = Self;
141  #[inline]
142  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
143    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
144    Self(b)
145  }
146}
147
148impl ::flatbuffers::Push for MessageHeader {
149    type Output = MessageHeader;
150    #[inline]
151    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
152        unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
153    }
154}
155
156impl ::flatbuffers::EndianScalar for MessageHeader {
157  type Scalar = u8;
158  #[inline]
159  fn to_little_endian(self) -> u8 {
160    self.0.to_le()
161  }
162  #[inline]
163  #[allow(clippy::wrong_self_convention)]
164  fn from_little_endian(v: u8) -> Self {
165    let b = u8::from_le(v);
166    Self(b)
167  }
168}
169
170impl<'a> ::flatbuffers::Verifiable for MessageHeader {
171  #[inline]
172  fn run_verifier(
173    v: &mut ::flatbuffers::Verifier, pos: usize
174  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
175    u8::run_verifier(v, pos)
176  }
177}
178
179impl ::flatbuffers::SimpleToVerifyInSlice for MessageHeader {}
180pub struct MessageHeaderUnionTableOffset {}
181
182pub enum ArrayMessageOffset {}
183#[derive(Copy, Clone, PartialEq)]
184
185/// Indicates the message body contains a flatbuffer Array message, followed by array buffers.
186pub struct ArrayMessage<'a> {
187  pub _tab: ::flatbuffers::Table<'a>,
188}
189
190impl<'a> ::flatbuffers::Follow<'a> for ArrayMessage<'a> {
191  type Inner = ArrayMessage<'a>;
192  #[inline]
193  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
194    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
195  }
196}
197
198impl<'a> ArrayMessage<'a> {
199  pub const VT_ROW_COUNT: ::flatbuffers::VOffsetT = 4;
200  pub const VT_ENCODINGS: ::flatbuffers::VOffsetT = 6;
201
202  #[inline]
203  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
204    ArrayMessage { _tab: table }
205  }
206  #[allow(unused_mut)]
207  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
208    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
209    args: &'args ArrayMessageArgs<'args>
210  ) -> ::flatbuffers::WIPOffset<ArrayMessage<'bldr>> {
211    let mut builder = ArrayMessageBuilder::new(_fbb);
212    if let Some(x) = args.encodings { builder.add_encodings(x); }
213    builder.add_row_count(args.row_count);
214    builder.finish()
215  }
216
217
218  /// The row count of the array.
219  #[inline]
220  pub fn row_count(&self) -> u32 {
221    // Safety:
222    // Created from valid Table for this object
223    // which contains a valid value in this slot
224    unsafe { self._tab.get::<u32>(ArrayMessage::VT_ROW_COUNT, Some(0)).unwrap()}
225  }
226  /// The encodings referenced by the array.
227  #[inline]
228  pub fn encodings(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>> {
229    // Safety:
230    // Created from valid Table for this object
231    // which contains a valid value in this slot
232    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>(ArrayMessage::VT_ENCODINGS, None)}
233  }
234}
235
236impl ::flatbuffers::Verifiable for ArrayMessage<'_> {
237  #[inline]
238  fn run_verifier(
239    v: &mut ::flatbuffers::Verifier, pos: usize
240  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
241    v.visit_table(pos)?
242     .visit_field::<u32>("row_count", Self::VT_ROW_COUNT, false)?
243     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>>>("encodings", Self::VT_ENCODINGS, false)?
244     .finish();
245    Ok(())
246  }
247}
248pub struct ArrayMessageArgs<'a> {
249    pub row_count: u32,
250    pub encodings: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>>,
251}
252impl<'a> Default for ArrayMessageArgs<'a> {
253  #[inline]
254  fn default() -> Self {
255    ArrayMessageArgs {
256      row_count: 0,
257      encodings: None,
258    }
259  }
260}
261
262pub struct ArrayMessageBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
263  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
264  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
265}
266impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ArrayMessageBuilder<'a, 'b, A> {
267  #[inline]
268  pub fn add_row_count(&mut self, row_count: u32) {
269    self.fbb_.push_slot::<u32>(ArrayMessage::VT_ROW_COUNT, row_count, 0);
270  }
271  #[inline]
272  pub fn add_encodings(&mut self, encodings: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<&'b  str>>>) {
273    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(ArrayMessage::VT_ENCODINGS, encodings);
274  }
275  #[inline]
276  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayMessageBuilder<'a, 'b, A> {
277    let start = _fbb.start_table();
278    ArrayMessageBuilder {
279      fbb_: _fbb,
280      start_: start,
281    }
282  }
283  #[inline]
284  pub fn finish(self) -> ::flatbuffers::WIPOffset<ArrayMessage<'a>> {
285    let o = self.fbb_.end_table(self.start_);
286    ::flatbuffers::WIPOffset::new(o.value())
287  }
288}
289
290impl ::core::fmt::Debug for ArrayMessage<'_> {
291  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
292    let mut ds = f.debug_struct("ArrayMessage");
293      ds.field("row_count", &self.row_count());
294      ds.field("encodings", &self.encodings());
295      ds.finish()
296  }
297}
298pub enum BufferMessageOffset {}
299#[derive(Copy, Clone, PartialEq)]
300
301/// Indicates the body contains a regular byte buffer.
302pub struct BufferMessage<'a> {
303  pub _tab: ::flatbuffers::Table<'a>,
304}
305
306impl<'a> ::flatbuffers::Follow<'a> for BufferMessage<'a> {
307  type Inner = BufferMessage<'a>;
308  #[inline]
309  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
310    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
311  }
312}
313
314impl<'a> BufferMessage<'a> {
315  pub const VT_ALIGNMENT_EXPONENT: ::flatbuffers::VOffsetT = 4;
316
317  #[inline]
318  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
319    BufferMessage { _tab: table }
320  }
321  #[allow(unused_mut)]
322  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
323    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
324    args: &'args BufferMessageArgs
325  ) -> ::flatbuffers::WIPOffset<BufferMessage<'bldr>> {
326    let mut builder = BufferMessageBuilder::new(_fbb);
327    builder.add_alignment_exponent(args.alignment_exponent);
328    builder.finish()
329  }
330
331
332  #[inline]
333  pub fn alignment_exponent(&self) -> u8 {
334    // Safety:
335    // Created from valid Table for this object
336    // which contains a valid value in this slot
337    unsafe { self._tab.get::<u8>(BufferMessage::VT_ALIGNMENT_EXPONENT, Some(0)).unwrap()}
338  }
339}
340
341impl ::flatbuffers::Verifiable for BufferMessage<'_> {
342  #[inline]
343  fn run_verifier(
344    v: &mut ::flatbuffers::Verifier, pos: usize
345  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
346    v.visit_table(pos)?
347     .visit_field::<u8>("alignment_exponent", Self::VT_ALIGNMENT_EXPONENT, false)?
348     .finish();
349    Ok(())
350  }
351}
352pub struct BufferMessageArgs {
353    pub alignment_exponent: u8,
354}
355impl<'a> Default for BufferMessageArgs {
356  #[inline]
357  fn default() -> Self {
358    BufferMessageArgs {
359      alignment_exponent: 0,
360    }
361  }
362}
363
364pub struct BufferMessageBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
365  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
366  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
367}
368impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> BufferMessageBuilder<'a, 'b, A> {
369  #[inline]
370  pub fn add_alignment_exponent(&mut self, alignment_exponent: u8) {
371    self.fbb_.push_slot::<u8>(BufferMessage::VT_ALIGNMENT_EXPONENT, alignment_exponent, 0);
372  }
373  #[inline]
374  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> BufferMessageBuilder<'a, 'b, A> {
375    let start = _fbb.start_table();
376    BufferMessageBuilder {
377      fbb_: _fbb,
378      start_: start,
379    }
380  }
381  #[inline]
382  pub fn finish(self) -> ::flatbuffers::WIPOffset<BufferMessage<'a>> {
383    let o = self.fbb_.end_table(self.start_);
384    ::flatbuffers::WIPOffset::new(o.value())
385  }
386}
387
388impl ::core::fmt::Debug for BufferMessage<'_> {
389  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
390    let mut ds = f.debug_struct("BufferMessage");
391      ds.field("alignment_exponent", &self.alignment_exponent());
392      ds.finish()
393  }
394}
395pub enum DTypeMessageOffset {}
396#[derive(Copy, Clone, PartialEq)]
397
398/// Indicates the body contains a flatbuffer DType message.
399pub struct DTypeMessage<'a> {
400  pub _tab: ::flatbuffers::Table<'a>,
401}
402
403impl<'a> ::flatbuffers::Follow<'a> for DTypeMessage<'a> {
404  type Inner = DTypeMessage<'a>;
405  #[inline]
406  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
407    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
408  }
409}
410
411impl<'a> DTypeMessage<'a> {
412
413  #[inline]
414  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
415    DTypeMessage { _tab: table }
416  }
417  #[allow(unused_mut)]
418  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
419    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
420    _args: &'args DTypeMessageArgs
421  ) -> ::flatbuffers::WIPOffset<DTypeMessage<'bldr>> {
422    let mut builder = DTypeMessageBuilder::new(_fbb);
423    builder.finish()
424  }
425
426}
427
428impl ::flatbuffers::Verifiable for DTypeMessage<'_> {
429  #[inline]
430  fn run_verifier(
431    v: &mut ::flatbuffers::Verifier, pos: usize
432  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
433    v.visit_table(pos)?
434     .finish();
435    Ok(())
436  }
437}
438pub struct DTypeMessageArgs {
439}
440impl<'a> Default for DTypeMessageArgs {
441  #[inline]
442  fn default() -> Self {
443    DTypeMessageArgs {
444    }
445  }
446}
447
448pub struct DTypeMessageBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
449  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
450  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
451}
452impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> DTypeMessageBuilder<'a, 'b, A> {
453  #[inline]
454  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> DTypeMessageBuilder<'a, 'b, A> {
455    let start = _fbb.start_table();
456    DTypeMessageBuilder {
457      fbb_: _fbb,
458      start_: start,
459    }
460  }
461  #[inline]
462  pub fn finish(self) -> ::flatbuffers::WIPOffset<DTypeMessage<'a>> {
463    let o = self.fbb_.end_table(self.start_);
464    ::flatbuffers::WIPOffset::new(o.value())
465  }
466}
467
468impl ::core::fmt::Debug for DTypeMessage<'_> {
469  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
470    let mut ds = f.debug_struct("DTypeMessage");
471      ds.finish()
472  }
473}
474pub enum MessageOffset {}
475#[derive(Copy, Clone, PartialEq)]
476
477pub struct Message<'a> {
478  pub _tab: ::flatbuffers::Table<'a>,
479}
480
481impl<'a> ::flatbuffers::Follow<'a> for Message<'a> {
482  type Inner = Message<'a>;
483  #[inline]
484  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
485    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
486  }
487}
488
489impl<'a> Message<'a> {
490  pub const VT_VERSION: ::flatbuffers::VOffsetT = 4;
491  pub const VT_HEADER_TYPE: ::flatbuffers::VOffsetT = 6;
492  pub const VT_HEADER: ::flatbuffers::VOffsetT = 8;
493  pub const VT_BODY_SIZE: ::flatbuffers::VOffsetT = 10;
494
495  #[inline]
496  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
497    Message { _tab: table }
498  }
499  #[allow(unused_mut)]
500  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
501    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
502    args: &'args MessageArgs
503  ) -> ::flatbuffers::WIPOffset<Message<'bldr>> {
504    let mut builder = MessageBuilder::new(_fbb);
505    builder.add_body_size(args.body_size);
506    if let Some(x) = args.header { builder.add_header(x); }
507    builder.add_header_type(args.header_type);
508    builder.add_version(args.version);
509    builder.finish()
510  }
511
512
513  #[inline]
514  pub fn version(&self) -> MessageVersion {
515    // Safety:
516    // Created from valid Table for this object
517    // which contains a valid value in this slot
518    unsafe { self._tab.get::<MessageVersion>(Message::VT_VERSION, Some(MessageVersion::V0)).unwrap()}
519  }
520  #[inline]
521  pub fn header_type(&self) -> MessageHeader {
522    // Safety:
523    // Created from valid Table for this object
524    // which contains a valid value in this slot
525    unsafe { self._tab.get::<MessageHeader>(Message::VT_HEADER_TYPE, Some(MessageHeader::NONE)).unwrap()}
526  }
527  #[inline]
528  pub fn header(&self) -> Option<::flatbuffers::Table<'a>> {
529    // Safety:
530    // Created from valid Table for this object
531    // which contains a valid value in this slot
532    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Message::VT_HEADER, None)}
533  }
534  #[inline]
535  pub fn body_size(&self) -> u64 {
536    // Safety:
537    // Created from valid Table for this object
538    // which contains a valid value in this slot
539    unsafe { self._tab.get::<u64>(Message::VT_BODY_SIZE, Some(0)).unwrap()}
540  }
541  #[inline]
542  #[allow(non_snake_case)]
543  pub fn header_as_array_message(&self) -> Option<ArrayMessage<'a>> {
544    if self.header_type() == MessageHeader::ArrayMessage {
545      self.header().map(|t| {
546       // Safety:
547       // Created from a valid Table for this object
548       // Which contains a valid union in this slot
549       unsafe { ArrayMessage::init_from_table(t) }
550     })
551    } else {
552      None
553    }
554  }
555
556  #[inline]
557  #[allow(non_snake_case)]
558  pub fn header_as_buffer_message(&self) -> Option<BufferMessage<'a>> {
559    if self.header_type() == MessageHeader::BufferMessage {
560      self.header().map(|t| {
561       // Safety:
562       // Created from a valid Table for this object
563       // Which contains a valid union in this slot
564       unsafe { BufferMessage::init_from_table(t) }
565     })
566    } else {
567      None
568    }
569  }
570
571  #[inline]
572  #[allow(non_snake_case)]
573  pub fn header_as_dtype_message(&self) -> Option<DTypeMessage<'a>> {
574    if self.header_type() == MessageHeader::DTypeMessage {
575      self.header().map(|t| {
576       // Safety:
577       // Created from a valid Table for this object
578       // Which contains a valid union in this slot
579       unsafe { DTypeMessage::init_from_table(t) }
580     })
581    } else {
582      None
583    }
584  }
585
586}
587
588impl ::flatbuffers::Verifiable for Message<'_> {
589  #[inline]
590  fn run_verifier(
591    v: &mut ::flatbuffers::Verifier, pos: usize
592  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
593    v.visit_table(pos)?
594     .visit_field::<MessageVersion>("version", Self::VT_VERSION, false)?
595     .visit_union::<MessageHeader, _>("header_type", Self::VT_HEADER_TYPE, "header", Self::VT_HEADER, false, |key, v, pos| {
596        match key {
597          MessageHeader::ArrayMessage => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<ArrayMessage>>("MessageHeader::ArrayMessage", pos),
598          MessageHeader::BufferMessage => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<BufferMessage>>("MessageHeader::BufferMessage", pos),
599          MessageHeader::DTypeMessage => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<DTypeMessage>>("MessageHeader::DTypeMessage", pos),
600          _ => Ok(()),
601        }
602     })?
603     .visit_field::<u64>("body_size", Self::VT_BODY_SIZE, false)?
604     .finish();
605    Ok(())
606  }
607}
608pub struct MessageArgs {
609    pub version: MessageVersion,
610    pub header_type: MessageHeader,
611    pub header: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
612    pub body_size: u64,
613}
614impl<'a> Default for MessageArgs {
615  #[inline]
616  fn default() -> Self {
617    MessageArgs {
618      version: MessageVersion::V0,
619      header_type: MessageHeader::NONE,
620      header: None,
621      body_size: 0,
622    }
623  }
624}
625
626pub struct MessageBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
627  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
628  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
629}
630impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MessageBuilder<'a, 'b, A> {
631  #[inline]
632  pub fn add_version(&mut self, version: MessageVersion) {
633    self.fbb_.push_slot::<MessageVersion>(Message::VT_VERSION, version, MessageVersion::V0);
634  }
635  #[inline]
636  pub fn add_header_type(&mut self, header_type: MessageHeader) {
637    self.fbb_.push_slot::<MessageHeader>(Message::VT_HEADER_TYPE, header_type, MessageHeader::NONE);
638  }
639  #[inline]
640  pub fn add_header(&mut self, header: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
641    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Message::VT_HEADER, header);
642  }
643  #[inline]
644  pub fn add_body_size(&mut self, body_size: u64) {
645    self.fbb_.push_slot::<u64>(Message::VT_BODY_SIZE, body_size, 0);
646  }
647  #[inline]
648  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MessageBuilder<'a, 'b, A> {
649    let start = _fbb.start_table();
650    MessageBuilder {
651      fbb_: _fbb,
652      start_: start,
653    }
654  }
655  #[inline]
656  pub fn finish(self) -> ::flatbuffers::WIPOffset<Message<'a>> {
657    let o = self.fbb_.end_table(self.start_);
658    ::flatbuffers::WIPOffset::new(o.value())
659  }
660}
661
662impl ::core::fmt::Debug for Message<'_> {
663  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
664    let mut ds = f.debug_struct("Message");
665      ds.field("version", &self.version());
666      ds.field("header_type", &self.header_type());
667      match self.header_type() {
668        MessageHeader::ArrayMessage => {
669          if let Some(x) = self.header_as_array_message() {
670            ds.field("header", &x)
671          } else {
672            ds.field("header", &"InvalidFlatbuffer: Union discriminant does not match value.")
673          }
674        },
675        MessageHeader::BufferMessage => {
676          if let Some(x) = self.header_as_buffer_message() {
677            ds.field("header", &x)
678          } else {
679            ds.field("header", &"InvalidFlatbuffer: Union discriminant does not match value.")
680          }
681        },
682        MessageHeader::DTypeMessage => {
683          if let Some(x) = self.header_as_dtype_message() {
684            ds.field("header", &x)
685          } else {
686            ds.field("header", &"InvalidFlatbuffer: Union discriminant does not match value.")
687          }
688        },
689        _ => {
690          let x: Option<()> = None;
691          ds.field("header", &x)
692        },
693      };
694      ds.field("body_size", &self.body_size());
695      ds.finish()
696  }
697}
698#[inline]
699/// Verifies that a buffer of bytes contains a `Message`
700/// and returns it.
701/// Note that verification is still experimental and may not
702/// catch every error, or be maximally performant. For the
703/// previous, unchecked, behavior use
704/// `root_as_message_unchecked`.
705pub fn root_as_message(buf: &[u8]) -> Result<Message<'_>, ::flatbuffers::InvalidFlatbuffer> {
706  ::flatbuffers::root::<Message>(buf)
707}
708#[inline]
709/// Verifies that a buffer of bytes contains a size prefixed
710/// `Message` and returns it.
711/// Note that verification is still experimental and may not
712/// catch every error, or be maximally performant. For the
713/// previous, unchecked, behavior use
714/// `size_prefixed_root_as_message_unchecked`.
715pub fn size_prefixed_root_as_message(buf: &[u8]) -> Result<Message<'_>, ::flatbuffers::InvalidFlatbuffer> {
716  ::flatbuffers::size_prefixed_root::<Message>(buf)
717}
718#[inline]
719/// Verifies, with the given options, that a buffer of bytes
720/// contains a `Message` and returns it.
721/// Note that verification is still experimental and may not
722/// catch every error, or be maximally performant. For the
723/// previous, unchecked, behavior use
724/// `root_as_message_unchecked`.
725pub fn root_as_message_with_opts<'b, 'o>(
726  opts: &'o ::flatbuffers::VerifierOptions,
727  buf: &'b [u8],
728) -> Result<Message<'b>, ::flatbuffers::InvalidFlatbuffer> {
729  ::flatbuffers::root_with_opts::<Message<'b>>(opts, buf)
730}
731#[inline]
732/// Verifies, with the given verifier options, that a buffer of
733/// bytes contains a size prefixed `Message` and returns
734/// it. Note that verification is still experimental and may not
735/// catch every error, or be maximally performant. For the
736/// previous, unchecked, behavior use
737/// `root_as_message_unchecked`.
738pub fn size_prefixed_root_as_message_with_opts<'b, 'o>(
739  opts: &'o ::flatbuffers::VerifierOptions,
740  buf: &'b [u8],
741) -> Result<Message<'b>, ::flatbuffers::InvalidFlatbuffer> {
742  ::flatbuffers::size_prefixed_root_with_opts::<Message<'b>>(opts, buf)
743}
744#[inline]
745/// Assumes, without verification, that a buffer of bytes contains a Message and returns it.
746/// # Safety
747/// Callers must trust the given bytes do indeed contain a valid `Message`.
748pub unsafe fn root_as_message_unchecked(buf: &[u8]) -> Message<'_> {
749  unsafe { ::flatbuffers::root_unchecked::<Message>(buf) }
750}
751#[inline]
752/// Assumes, without verification, that a buffer of bytes contains a size prefixed Message and returns it.
753/// # Safety
754/// Callers must trust the given bytes do indeed contain a valid size prefixed `Message`.
755pub unsafe fn size_prefixed_root_as_message_unchecked(buf: &[u8]) -> Message<'_> {
756  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Message>(buf) }
757}
758#[inline]
759pub fn finish_message_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
760    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
761    root: ::flatbuffers::WIPOffset<Message<'a>>) {
762  fbb.finish(root, None);
763}
764
765#[inline]
766pub fn finish_size_prefixed_message_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Message<'a>>) {
767  fbb.finish_size_prefixed(root, None);
768}
vortex_flatbuffers/generated/message.rs

vortex_flatbuffers/generated/
message.rs
