vortex_flatbuffers/generated/
message.rs

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

vortex_flatbuffers/generated/
message.rs
