vortex_flatbuffers/generated/
footer.rs

1// automatically generated by the FlatBuffers compiler, do not modify
2// @generated
3extern crate alloc;
4
5use crate::array::*;
6use crate::layout::*;
7
8#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
9pub const ENUM_MIN_COMPRESSION_SCHEME: 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_COMPRESSION_SCHEME: u8 = 3;
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_COMPRESSION_SCHEME: [CompressionScheme; 4] = [
15  CompressionScheme::None,
16  CompressionScheme::LZ4,
17  CompressionScheme::ZLib,
18  CompressionScheme::ZStd,
19];
20
21#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
22#[repr(transparent)]
23pub struct CompressionScheme(pub u8);
24#[allow(non_upper_case_globals)]
25impl CompressionScheme {
26  pub const None: Self = Self(0);
27  pub const LZ4: Self = Self(1);
28  pub const ZLib: Self = Self(2);
29  pub const ZStd: Self = Self(3);
30
31  pub const ENUM_MIN: u8 = 0;
32  pub const ENUM_MAX: u8 = 3;
33  pub const ENUM_VALUES: &'static [Self] = &[
34    Self::None,
35    Self::LZ4,
36    Self::ZLib,
37    Self::ZStd,
38  ];
39  /// Returns the variant's name or "" if unknown.
40  pub fn variant_name(self) -> Option<&'static str> {
41    match self {
42      Self::None => Some("None"),
43      Self::LZ4 => Some("LZ4"),
44      Self::ZLib => Some("ZLib"),
45      Self::ZStd => Some("ZStd"),
46      _ => None,
47    }
48  }
49}
50impl ::core::fmt::Debug for CompressionScheme {
51  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
52    if let Some(name) = self.variant_name() {
53      f.write_str(name)
54    } else {
55      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
56    }
57  }
58}
59impl<'a> ::flatbuffers::Follow<'a> for CompressionScheme {
60  type Inner = Self;
61  #[inline]
62  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
63    let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
64    Self(b)
65  }
66}
67
68impl ::flatbuffers::Push for CompressionScheme {
69    type Output = CompressionScheme;
70    #[inline]
71    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
72        unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
73    }
74}
75
76impl ::flatbuffers::EndianScalar for CompressionScheme {
77  type Scalar = u8;
78  #[inline]
79  fn to_little_endian(self) -> u8 {
80    self.0.to_le()
81  }
82  #[inline]
83  #[allow(clippy::wrong_self_convention)]
84  fn from_little_endian(v: u8) -> Self {
85    let b = u8::from_le(v);
86    Self(b)
87  }
88}
89
90impl<'a> ::flatbuffers::Verifiable for CompressionScheme {
91  #[inline]
92  fn run_verifier(
93    v: &mut ::flatbuffers::Verifier, pos: usize
94  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
95    u8::run_verifier(v, pos)
96  }
97}
98
99impl ::flatbuffers::SimpleToVerifyInSlice for CompressionScheme {}
100/// A `SegmentSpec` acts as the locator for a buffer within the file.
101// struct SegmentSpec, aligned to 8
102#[repr(transparent)]
103#[derive(Clone, Copy, PartialEq)]
104pub struct SegmentSpec(pub [u8; 16]);
105impl Default for SegmentSpec { 
106  fn default() -> Self { 
107    Self([0; 16])
108  }
109}
110impl ::core::fmt::Debug for SegmentSpec {
111  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
112    f.debug_struct("SegmentSpec")
113      .field("offset", &self.offset())
114      .field("length", &self.length())
115      .field("alignment_exponent", &self.alignment_exponent())
116      .field("_compression", &self._compression())
117      .field("_encryption", &self._encryption())
118      .finish()
119  }
120}
121
122impl ::flatbuffers::SimpleToVerifyInSlice for SegmentSpec {}
123impl<'a> ::flatbuffers::Follow<'a> for SegmentSpec {
124  type Inner = &'a SegmentSpec;
125  #[inline]
126  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
127    unsafe { <&'a SegmentSpec>::follow(buf, loc) }
128  }
129}
130impl<'a> ::flatbuffers::Follow<'a> for &'a SegmentSpec {
131  type Inner = &'a SegmentSpec;
132  #[inline]
133  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
134    unsafe { ::flatbuffers::follow_cast_ref::<SegmentSpec>(buf, loc) }
135  }
136}
137impl<'b> ::flatbuffers::Push for SegmentSpec {
138    type Output = SegmentSpec;
139    #[inline]
140    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
141        let src = unsafe { ::core::slice::from_raw_parts(self as *const SegmentSpec as *const u8, <Self as ::flatbuffers::Push>::size()) };
142        dst.copy_from_slice(src);
143    }
144    #[inline]
145    fn alignment() -> ::flatbuffers::PushAlignment {
146        ::flatbuffers::PushAlignment::new(8)
147    }
148}
149
150impl<'a> ::flatbuffers::Verifiable for SegmentSpec {
151  #[inline]
152  fn run_verifier(
153    v: &mut ::flatbuffers::Verifier, pos: usize
154  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
155    v.in_buffer::<Self>(pos)
156  }
157}
158
159impl<'a> SegmentSpec {
160  #[allow(clippy::too_many_arguments)]
161  pub fn new(
162    offset: u64,
163    length: u32,
164    alignment_exponent: u8,
165    _compression: u8,
166    _encryption: u16,
167  ) -> Self {
168    let mut s = Self([0; 16]);
169    s.set_offset(offset);
170    s.set_length(length);
171    s.set_alignment_exponent(alignment_exponent);
172    s.set__compression(_compression);
173    s.set__encryption(_encryption);
174    s
175  }
176
177  /// Offset relative to the start of the file.
178  pub fn offset(&self) -> u64 {
179    let mut mem = ::core::mem::MaybeUninit::<<u64 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
180    // Safety:
181    // Created from a valid Table for this object
182    // Which contains a valid value in this slot
183    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
184      ::core::ptr::copy_nonoverlapping(
185        self.0[0..].as_ptr(),
186        mem.as_mut_ptr() as *mut u8,
187        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
188      );
189      mem.assume_init()
190    })
191  }
192
193  pub fn set_offset(&mut self, x: u64) {
194    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
195    // Safety:
196    // Created from a valid Table for this object
197    // Which contains a valid value in this slot
198    unsafe {
199      ::core::ptr::copy_nonoverlapping(
200        &x_le as *const _ as *const u8,
201        self.0[0..].as_mut_ptr(),
202        ::core::mem::size_of::<<u64 as ::flatbuffers::EndianScalar>::Scalar>(),
203      );
204    }
205  }
206
207  /// Length in bytes of the segment.
208  pub fn length(&self) -> u32 {
209    let mut mem = ::core::mem::MaybeUninit::<<u32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
210    // Safety:
211    // Created from a valid Table for this object
212    // Which contains a valid value in this slot
213    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
214      ::core::ptr::copy_nonoverlapping(
215        self.0[8..].as_ptr(),
216        mem.as_mut_ptr() as *mut u8,
217        ::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(),
218      );
219      mem.assume_init()
220    })
221  }
222
223  pub fn set_length(&mut self, x: u32) {
224    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
225    // Safety:
226    // Created from a valid Table for this object
227    // Which contains a valid value in this slot
228    unsafe {
229      ::core::ptr::copy_nonoverlapping(
230        &x_le as *const _ as *const u8,
231        self.0[8..].as_mut_ptr(),
232        ::core::mem::size_of::<<u32 as ::flatbuffers::EndianScalar>::Scalar>(),
233      );
234    }
235  }
236
237  /// Base-2 exponent of the alignment of the segment.
238  pub fn alignment_exponent(&self) -> u8 {
239    let mut mem = ::core::mem::MaybeUninit::<<u8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
240    // Safety:
241    // Created from a valid Table for this object
242    // Which contains a valid value in this slot
243    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
244      ::core::ptr::copy_nonoverlapping(
245        self.0[12..].as_ptr(),
246        mem.as_mut_ptr() as *mut u8,
247        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
248      );
249      mem.assume_init()
250    })
251  }
252
253  pub fn set_alignment_exponent(&mut self, x: u8) {
254    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
255    // Safety:
256    // Created from a valid Table for this object
257    // Which contains a valid value in this slot
258    unsafe {
259      ::core::ptr::copy_nonoverlapping(
260        &x_le as *const _ as *const u8,
261        self.0[12..].as_mut_ptr(),
262        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
263      );
264    }
265  }
266
267  pub fn _compression(&self) -> u8 {
268    let mut mem = ::core::mem::MaybeUninit::<<u8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
269    // Safety:
270    // Created from a valid Table for this object
271    // Which contains a valid value in this slot
272    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
273      ::core::ptr::copy_nonoverlapping(
274        self.0[13..].as_ptr(),
275        mem.as_mut_ptr() as *mut u8,
276        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
277      );
278      mem.assume_init()
279    })
280  }
281
282  pub fn set__compression(&mut self, x: u8) {
283    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
284    // Safety:
285    // Created from a valid Table for this object
286    // Which contains a valid value in this slot
287    unsafe {
288      ::core::ptr::copy_nonoverlapping(
289        &x_le as *const _ as *const u8,
290        self.0[13..].as_mut_ptr(),
291        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
292      );
293    }
294  }
295
296  pub fn _encryption(&self) -> u16 {
297    let mut mem = ::core::mem::MaybeUninit::<<u16 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
298    // Safety:
299    // Created from a valid Table for this object
300    // Which contains a valid value in this slot
301    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
302      ::core::ptr::copy_nonoverlapping(
303        self.0[14..].as_ptr(),
304        mem.as_mut_ptr() as *mut u8,
305        ::core::mem::size_of::<<u16 as ::flatbuffers::EndianScalar>::Scalar>(),
306      );
307      mem.assume_init()
308    })
309  }
310
311  pub fn set__encryption(&mut self, x: u16) {
312    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
313    // Safety:
314    // Created from a valid Table for this object
315    // Which contains a valid value in this slot
316    unsafe {
317      ::core::ptr::copy_nonoverlapping(
318        &x_le as *const _ as *const u8,
319        self.0[14..].as_mut_ptr(),
320        ::core::mem::size_of::<<u16 as ::flatbuffers::EndianScalar>::Scalar>(),
321      );
322    }
323  }
324
325}
326
327pub enum PostscriptOffset {}
328#[derive(Copy, Clone, PartialEq)]
329
330/// The `Postscript` is guaranteed by the file format to never exceed
331/// 65528 bytes (i.e., u16::MAX - 8 bytes) in length, and is immediately
332/// followed by an 8-byte `EndOfFile` struct.
333///
334/// An initial read of a Vortex file defaults to at least 64KB (u16::MAX bytes) and therefore
335/// is guaranteed to cover at least the Postscript.
336///
337/// The reason for a postscript at all is to ensure minimal but all necessary footer information
338/// can be read in two round trips. Since the DType is optional and possibly large, it lives in
339/// its own segment. If the footer were arbitrary size, with a pointer to the DType segment, then
340/// in the worst case we would need one round trip to read the footer length, one to read the full
341/// footer and parse the DType offset, and a third to fetch the DType segment.
342///
343/// The segments pointed to by the postscript have inline compression and encryption specs to avoid
344/// the need to fetch encryption schemes up-front.
345///
346/// New fields must be appended to preserve FlatBuffers field-order compatibility with old readers.
347pub struct Postscript<'a> {
348  pub _tab: ::flatbuffers::Table<'a>,
349}
350
351impl<'a> ::flatbuffers::Follow<'a> for Postscript<'a> {
352  type Inner = Postscript<'a>;
353  #[inline]
354  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
355    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
356  }
357}
358
359impl<'a> Postscript<'a> {
360  pub const VT_DTYPE: ::flatbuffers::VOffsetT = 4;
361  pub const VT_LAYOUT: ::flatbuffers::VOffsetT = 6;
362  pub const VT_STATISTICS: ::flatbuffers::VOffsetT = 8;
363  pub const VT_FOOTER: ::flatbuffers::VOffsetT = 10;
364  pub const VT_METADATA: ::flatbuffers::VOffsetT = 12;
365
366  #[inline]
367  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
368    Postscript { _tab: table }
369  }
370  #[allow(unused_mut)]
371  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
372    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
373    args: &'args PostscriptArgs<'args>
374  ) -> ::flatbuffers::WIPOffset<Postscript<'bldr>> {
375    let mut builder = PostscriptBuilder::new(_fbb);
376    if let Some(x) = args.metadata { builder.add_metadata(x); }
377    if let Some(x) = args.footer { builder.add_footer(x); }
378    if let Some(x) = args.statistics { builder.add_statistics(x); }
379    if let Some(x) = args.layout { builder.add_layout(x); }
380    if let Some(x) = args.dtype { builder.add_dtype(x); }
381    builder.finish()
382  }
383
384
385  /// Segment containing the root `DType` flatbuffer.
386  #[inline]
387  pub fn dtype(&self) -> Option<PostscriptSegment<'a>> {
388    // Safety:
389    // Created from valid Table for this object
390    // which contains a valid value in this slot
391    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(Postscript::VT_DTYPE, None)}
392  }
393  /// Segment containing the root `Layout` flatbuffer (required).
394  #[inline]
395  pub fn layout(&self) -> Option<PostscriptSegment<'a>> {
396    // Safety:
397    // Created from valid Table for this object
398    // which contains a valid value in this slot
399    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(Postscript::VT_LAYOUT, None)}
400  }
401  /// Segment containing the file-level `Statistics` flatbuffer.
402  #[inline]
403  pub fn statistics(&self) -> Option<PostscriptSegment<'a>> {
404    // Safety:
405    // Created from valid Table for this object
406    // which contains a valid value in this slot
407    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(Postscript::VT_STATISTICS, None)}
408  }
409  /// Segment containing the 'Footer' flatbuffer (required)
410  #[inline]
411  pub fn footer(&self) -> Option<PostscriptSegment<'a>> {
412    // Safety:
413    // Created from valid Table for this object
414    // which contains a valid value in this slot
415    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(Postscript::VT_FOOTER, None)}
416  }
417  /// User-defined metadata segments keyed by string. Keys must be unique, non-empty, and at most
418  /// 64 UTF-8 bytes; readers reject postscripts that violate these limits.
419  #[inline]
420  pub fn metadata(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'a>>>> {
421    // Safety:
422    // Created from valid Table for this object
423    // which contains a valid value in this slot
424    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata>>>>(Postscript::VT_METADATA, None)}
425  }
426}
427
428impl ::flatbuffers::Verifiable for Postscript<'_> {
429  #[inline]
430  fn run_verifier(
431    v: &mut ::flatbuffers::Verifier, pos: usize
432  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
433    v.visit_table(pos)?
434     .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("dtype", Self::VT_DTYPE, false)?
435     .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("layout", Self::VT_LAYOUT, false)?
436     .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("statistics", Self::VT_STATISTICS, false)?
437     .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("footer", Self::VT_FOOTER, false)?
438     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<PostscriptMetadata>>>>("metadata", Self::VT_METADATA, false)?
439     .finish();
440    Ok(())
441  }
442}
443pub struct PostscriptArgs<'a> {
444    pub dtype: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
445    pub layout: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
446    pub statistics: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
447    pub footer: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
448    pub metadata: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'a>>>>>,
449}
450impl<'a> Default for PostscriptArgs<'a> {
451  #[inline]
452  fn default() -> Self {
453    PostscriptArgs {
454      dtype: None,
455      layout: None,
456      statistics: None,
457      footer: None,
458      metadata: None,
459    }
460  }
461}
462
463pub struct PostscriptBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
464  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
465  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
466}
467impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PostscriptBuilder<'a, 'b, A> {
468  #[inline]
469  pub fn add_dtype(&mut self, dtype: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
470    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(Postscript::VT_DTYPE, dtype);
471  }
472  #[inline]
473  pub fn add_layout(&mut self, layout: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
474    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(Postscript::VT_LAYOUT, layout);
475  }
476  #[inline]
477  pub fn add_statistics(&mut self, statistics: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
478    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(Postscript::VT_STATISTICS, statistics);
479  }
480  #[inline]
481  pub fn add_footer(&mut self, footer: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
482    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(Postscript::VT_FOOTER, footer);
483  }
484  #[inline]
485  pub fn add_metadata(&mut self, metadata: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<PostscriptMetadata<'b >>>>) {
486    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Postscript::VT_METADATA, metadata);
487  }
488  #[inline]
489  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PostscriptBuilder<'a, 'b, A> {
490    let start = _fbb.start_table();
491    PostscriptBuilder {
492      fbb_: _fbb,
493      start_: start,
494    }
495  }
496  #[inline]
497  pub fn finish(self) -> ::flatbuffers::WIPOffset<Postscript<'a>> {
498    let o = self.fbb_.end_table(self.start_);
499    ::flatbuffers::WIPOffset::new(o.value())
500  }
501}
502
503impl ::core::fmt::Debug for Postscript<'_> {
504  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
505    let mut ds = f.debug_struct("Postscript");
506      ds.field("dtype", &self.dtype());
507      ds.field("layout", &self.layout());
508      ds.field("statistics", &self.statistics());
509      ds.field("footer", &self.footer());
510      ds.field("metadata", &self.metadata());
511      ds.finish()
512  }
513}
514pub enum PostscriptMetadataOffset {}
515#[derive(Copy, Clone, PartialEq)]
516
517/// A keyed user-defined metadata segment.
518pub struct PostscriptMetadata<'a> {
519  pub _tab: ::flatbuffers::Table<'a>,
520}
521
522impl<'a> ::flatbuffers::Follow<'a> for PostscriptMetadata<'a> {
523  type Inner = PostscriptMetadata<'a>;
524  #[inline]
525  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
526    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
527  }
528}
529
530impl<'a> PostscriptMetadata<'a> {
531  pub const VT_KEY: ::flatbuffers::VOffsetT = 4;
532  pub const VT_SEGMENT: ::flatbuffers::VOffsetT = 6;
533
534  #[inline]
535  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
536    PostscriptMetadata { _tab: table }
537  }
538  #[allow(unused_mut)]
539  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
540    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
541    args: &'args PostscriptMetadataArgs<'args>
542  ) -> ::flatbuffers::WIPOffset<PostscriptMetadata<'bldr>> {
543    let mut builder = PostscriptMetadataBuilder::new(_fbb);
544    if let Some(x) = args.segment { builder.add_segment(x); }
545    if let Some(x) = args.key { builder.add_key(x); }
546    builder.finish()
547  }
548
549
550  #[inline]
551  pub fn key(&self) -> &'a str {
552    // Safety:
553    // Created from valid Table for this object
554    // which contains a valid value in this slot
555    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(PostscriptMetadata::VT_KEY, None).unwrap()}
556  }
557  #[inline]
558  pub fn segment(&self) -> PostscriptSegment<'a> {
559    // Safety:
560    // Created from valid Table for this object
561    // which contains a valid value in this slot
562    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>(PostscriptMetadata::VT_SEGMENT, None).unwrap()}
563  }
564}
565
566impl ::flatbuffers::Verifiable for PostscriptMetadata<'_> {
567  #[inline]
568  fn run_verifier(
569    v: &mut ::flatbuffers::Verifier, pos: usize
570  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
571    v.visit_table(pos)?
572     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("key", Self::VT_KEY, true)?
573     .visit_field::<::flatbuffers::ForwardsUOffset<PostscriptSegment>>("segment", Self::VT_SEGMENT, true)?
574     .finish();
575    Ok(())
576  }
577}
578pub struct PostscriptMetadataArgs<'a> {
579    pub key: Option<::flatbuffers::WIPOffset<&'a str>>,
580    pub segment: Option<::flatbuffers::WIPOffset<PostscriptSegment<'a>>>,
581}
582impl<'a> Default for PostscriptMetadataArgs<'a> {
583  #[inline]
584  fn default() -> Self {
585    PostscriptMetadataArgs {
586      key: None, // required field
587      segment: None, // required field
588    }
589  }
590}
591
592pub struct PostscriptMetadataBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
593  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
594  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
595}
596impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PostscriptMetadataBuilder<'a, 'b, A> {
597  #[inline]
598  pub fn add_key(&mut self, key: ::flatbuffers::WIPOffset<&'b  str>) {
599    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(PostscriptMetadata::VT_KEY, key);
600  }
601  #[inline]
602  pub fn add_segment(&mut self, segment: ::flatbuffers::WIPOffset<PostscriptSegment<'b >>) {
603    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<PostscriptSegment>>(PostscriptMetadata::VT_SEGMENT, segment);
604  }
605  #[inline]
606  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PostscriptMetadataBuilder<'a, 'b, A> {
607    let start = _fbb.start_table();
608    PostscriptMetadataBuilder {
609      fbb_: _fbb,
610      start_: start,
611    }
612  }
613  #[inline]
614  pub fn finish(self) -> ::flatbuffers::WIPOffset<PostscriptMetadata<'a>> {
615    let o = self.fbb_.end_table(self.start_);
616    self.fbb_.required(o, PostscriptMetadata::VT_KEY,"key");
617    self.fbb_.required(o, PostscriptMetadata::VT_SEGMENT,"segment");
618    ::flatbuffers::WIPOffset::new(o.value())
619  }
620}
621
622impl ::core::fmt::Debug for PostscriptMetadata<'_> {
623  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
624    let mut ds = f.debug_struct("PostscriptMetadata");
625      ds.field("key", &self.key());
626      ds.field("segment", &self.segment());
627      ds.finish()
628  }
629}
630pub enum PostscriptSegmentOffset {}
631#[derive(Copy, Clone, PartialEq)]
632
633/// A `PostscriptSegment` describes the location of a segment in the file without referencing any
634/// specification objects. That is, encryption and compression are defined inline.
635pub struct PostscriptSegment<'a> {
636  pub _tab: ::flatbuffers::Table<'a>,
637}
638
639impl<'a> ::flatbuffers::Follow<'a> for PostscriptSegment<'a> {
640  type Inner = PostscriptSegment<'a>;
641  #[inline]
642  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
643    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
644  }
645}
646
647impl<'a> PostscriptSegment<'a> {
648  pub const VT_OFFSET: ::flatbuffers::VOffsetT = 4;
649  pub const VT_LENGTH: ::flatbuffers::VOffsetT = 6;
650  pub const VT_ALIGNMENT_EXPONENT: ::flatbuffers::VOffsetT = 8;
651  pub const VT__COMPRESSION: ::flatbuffers::VOffsetT = 10;
652  pub const VT__ENCRYPTION: ::flatbuffers::VOffsetT = 12;
653
654  #[inline]
655  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
656    PostscriptSegment { _tab: table }
657  }
658  #[allow(unused_mut)]
659  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
660    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
661    args: &'args PostscriptSegmentArgs<'args>
662  ) -> ::flatbuffers::WIPOffset<PostscriptSegment<'bldr>> {
663    let mut builder = PostscriptSegmentBuilder::new(_fbb);
664    builder.add_offset(args.offset);
665    if let Some(x) = args._encryption { builder.add__encryption(x); }
666    if let Some(x) = args._compression { builder.add__compression(x); }
667    builder.add_length(args.length);
668    builder.add_alignment_exponent(args.alignment_exponent);
669    builder.finish()
670  }
671
672
673  #[inline]
674  pub fn offset(&self) -> u64 {
675    // Safety:
676    // Created from valid Table for this object
677    // which contains a valid value in this slot
678    unsafe { self._tab.get::<u64>(PostscriptSegment::VT_OFFSET, Some(0)).unwrap()}
679  }
680  #[inline]
681  pub fn length(&self) -> u32 {
682    // Safety:
683    // Created from valid Table for this object
684    // which contains a valid value in this slot
685    unsafe { self._tab.get::<u32>(PostscriptSegment::VT_LENGTH, Some(0)).unwrap()}
686  }
687  #[inline]
688  pub fn alignment_exponent(&self) -> u8 {
689    // Safety:
690    // Created from valid Table for this object
691    // which contains a valid value in this slot
692    unsafe { self._tab.get::<u8>(PostscriptSegment::VT_ALIGNMENT_EXPONENT, Some(0)).unwrap()}
693  }
694  #[inline]
695  pub fn _compression(&self) -> Option<CompressionSpec<'a>> {
696    // Safety:
697    // Created from valid Table for this object
698    // which contains a valid value in this slot
699    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<CompressionSpec>>(PostscriptSegment::VT__COMPRESSION, None)}
700  }
701  #[inline]
702  pub fn _encryption(&self) -> Option<EncryptionSpec<'a>> {
703    // Safety:
704    // Created from valid Table for this object
705    // which contains a valid value in this slot
706    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<EncryptionSpec>>(PostscriptSegment::VT__ENCRYPTION, None)}
707  }
708}
709
710impl ::flatbuffers::Verifiable for PostscriptSegment<'_> {
711  #[inline]
712  fn run_verifier(
713    v: &mut ::flatbuffers::Verifier, pos: usize
714  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
715    v.visit_table(pos)?
716     .visit_field::<u64>("offset", Self::VT_OFFSET, false)?
717     .visit_field::<u32>("length", Self::VT_LENGTH, false)?
718     .visit_field::<u8>("alignment_exponent", Self::VT_ALIGNMENT_EXPONENT, false)?
719     .visit_field::<::flatbuffers::ForwardsUOffset<CompressionSpec>>("_compression", Self::VT__COMPRESSION, false)?
720     .visit_field::<::flatbuffers::ForwardsUOffset<EncryptionSpec>>("_encryption", Self::VT__ENCRYPTION, false)?
721     .finish();
722    Ok(())
723  }
724}
725pub struct PostscriptSegmentArgs<'a> {
726    pub offset: u64,
727    pub length: u32,
728    pub alignment_exponent: u8,
729    pub _compression: Option<::flatbuffers::WIPOffset<CompressionSpec<'a>>>,
730    pub _encryption: Option<::flatbuffers::WIPOffset<EncryptionSpec<'a>>>,
731}
732impl<'a> Default for PostscriptSegmentArgs<'a> {
733  #[inline]
734  fn default() -> Self {
735    PostscriptSegmentArgs {
736      offset: 0,
737      length: 0,
738      alignment_exponent: 0,
739      _compression: None,
740      _encryption: None,
741    }
742  }
743}
744
745pub struct PostscriptSegmentBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
746  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
747  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
748}
749impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> PostscriptSegmentBuilder<'a, 'b, A> {
750  #[inline]
751  pub fn add_offset(&mut self, offset: u64) {
752    self.fbb_.push_slot::<u64>(PostscriptSegment::VT_OFFSET, offset, 0);
753  }
754  #[inline]
755  pub fn add_length(&mut self, length: u32) {
756    self.fbb_.push_slot::<u32>(PostscriptSegment::VT_LENGTH, length, 0);
757  }
758  #[inline]
759  pub fn add_alignment_exponent(&mut self, alignment_exponent: u8) {
760    self.fbb_.push_slot::<u8>(PostscriptSegment::VT_ALIGNMENT_EXPONENT, alignment_exponent, 0);
761  }
762  #[inline]
763  pub fn add__compression(&mut self, _compression: ::flatbuffers::WIPOffset<CompressionSpec<'b >>) {
764    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<CompressionSpec>>(PostscriptSegment::VT__COMPRESSION, _compression);
765  }
766  #[inline]
767  pub fn add__encryption(&mut self, _encryption: ::flatbuffers::WIPOffset<EncryptionSpec<'b >>) {
768    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<EncryptionSpec>>(PostscriptSegment::VT__ENCRYPTION, _encryption);
769  }
770  #[inline]
771  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> PostscriptSegmentBuilder<'a, 'b, A> {
772    let start = _fbb.start_table();
773    PostscriptSegmentBuilder {
774      fbb_: _fbb,
775      start_: start,
776    }
777  }
778  #[inline]
779  pub fn finish(self) -> ::flatbuffers::WIPOffset<PostscriptSegment<'a>> {
780    let o = self.fbb_.end_table(self.start_);
781    ::flatbuffers::WIPOffset::new(o.value())
782  }
783}
784
785impl ::core::fmt::Debug for PostscriptSegment<'_> {
786  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
787    let mut ds = f.debug_struct("PostscriptSegment");
788      ds.field("offset", &self.offset());
789      ds.field("length", &self.length());
790      ds.field("alignment_exponent", &self.alignment_exponent());
791      ds.field("_compression", &self._compression());
792      ds.field("_encryption", &self._encryption());
793      ds.finish()
794  }
795}
796pub enum FileStatisticsOffset {}
797#[derive(Copy, Clone, PartialEq)]
798
799/// The `FileStatistics` object contains file-level statistics for the Vortex file.
800pub struct FileStatistics<'a> {
801  pub _tab: ::flatbuffers::Table<'a>,
802}
803
804impl<'a> ::flatbuffers::Follow<'a> for FileStatistics<'a> {
805  type Inner = FileStatistics<'a>;
806  #[inline]
807  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
808    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
809  }
810}
811
812impl<'a> FileStatistics<'a> {
813  pub const VT_FIELD_STATS: ::flatbuffers::VOffsetT = 4;
814
815  #[inline]
816  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
817    FileStatistics { _tab: table }
818  }
819  #[allow(unused_mut)]
820  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
821    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
822    args: &'args FileStatisticsArgs<'args>
823  ) -> ::flatbuffers::WIPOffset<FileStatistics<'bldr>> {
824    let mut builder = FileStatisticsBuilder::new(_fbb);
825    if let Some(x) = args.field_stats { builder.add_field_stats(x); }
826    builder.finish()
827  }
828
829
830  /// Statistics for each field in the root schema. If the root schema is not a struct, there will
831  /// be a single entry in this array.
832  #[inline]
833  pub fn field_stats(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ArrayStats<'a>>>> {
834    // Safety:
835    // Created from valid Table for this object
836    // which contains a valid value in this slot
837    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ArrayStats>>>>(FileStatistics::VT_FIELD_STATS, None)}
838  }
839}
840
841impl ::flatbuffers::Verifiable for FileStatistics<'_> {
842  #[inline]
843  fn run_verifier(
844    v: &mut ::flatbuffers::Verifier, pos: usize
845  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
846    v.visit_table(pos)?
847     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ArrayStats>>>>("field_stats", Self::VT_FIELD_STATS, false)?
848     .finish();
849    Ok(())
850  }
851}
852pub struct FileStatisticsArgs<'a> {
853    pub field_stats: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ArrayStats<'a>>>>>,
854}
855impl<'a> Default for FileStatisticsArgs<'a> {
856  #[inline]
857  fn default() -> Self {
858    FileStatisticsArgs {
859      field_stats: None,
860    }
861  }
862}
863
864pub struct FileStatisticsBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
865  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
866  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
867}
868impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> FileStatisticsBuilder<'a, 'b, A> {
869  #[inline]
870  pub fn add_field_stats(&mut self, field_stats: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<ArrayStats<'b >>>>) {
871    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(FileStatistics::VT_FIELD_STATS, field_stats);
872  }
873  #[inline]
874  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> FileStatisticsBuilder<'a, 'b, A> {
875    let start = _fbb.start_table();
876    FileStatisticsBuilder {
877      fbb_: _fbb,
878      start_: start,
879    }
880  }
881  #[inline]
882  pub fn finish(self) -> ::flatbuffers::WIPOffset<FileStatistics<'a>> {
883    let o = self.fbb_.end_table(self.start_);
884    ::flatbuffers::WIPOffset::new(o.value())
885  }
886}
887
888impl ::core::fmt::Debug for FileStatistics<'_> {
889  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
890    let mut ds = f.debug_struct("FileStatistics");
891      ds.field("field_stats", &self.field_stats());
892      ds.finish()
893  }
894}
895pub enum FooterOffset {}
896#[derive(Copy, Clone, PartialEq)]
897
898/// The `Registry` object stores dictionary-encoded configuration for segments,
899/// compression schemes, encryption schemes, etc.
900pub struct Footer<'a> {
901  pub _tab: ::flatbuffers::Table<'a>,
902}
903
904impl<'a> ::flatbuffers::Follow<'a> for Footer<'a> {
905  type Inner = Footer<'a>;
906  #[inline]
907  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
908    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
909  }
910}
911
912impl<'a> Footer<'a> {
913  pub const VT_ARRAY_SPECS: ::flatbuffers::VOffsetT = 4;
914  pub const VT_LAYOUT_SPECS: ::flatbuffers::VOffsetT = 6;
915  pub const VT_SEGMENT_SPECS: ::flatbuffers::VOffsetT = 8;
916  pub const VT_COMPRESSION_SPECS: ::flatbuffers::VOffsetT = 10;
917  pub const VT_ENCRYPTION_SPECS: ::flatbuffers::VOffsetT = 12;
918
919  #[inline]
920  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
921    Footer { _tab: table }
922  }
923  #[allow(unused_mut)]
924  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
925    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
926    args: &'args FooterArgs<'args>
927  ) -> ::flatbuffers::WIPOffset<Footer<'bldr>> {
928    let mut builder = FooterBuilder::new(_fbb);
929    if let Some(x) = args.encryption_specs { builder.add_encryption_specs(x); }
930    if let Some(x) = args.compression_specs { builder.add_compression_specs(x); }
931    if let Some(x) = args.segment_specs { builder.add_segment_specs(x); }
932    if let Some(x) = args.layout_specs { builder.add_layout_specs(x); }
933    if let Some(x) = args.array_specs { builder.add_array_specs(x); }
934    builder.finish()
935  }
936
937
938  #[inline]
939  pub fn array_specs(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ArraySpec<'a>>>> {
940    // Safety:
941    // Created from valid Table for this object
942    // which contains a valid value in this slot
943    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ArraySpec>>>>(Footer::VT_ARRAY_SPECS, None)}
944  }
945  #[inline]
946  pub fn layout_specs(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<LayoutSpec<'a>>>> {
947    // Safety:
948    // Created from valid Table for this object
949    // which contains a valid value in this slot
950    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<LayoutSpec>>>>(Footer::VT_LAYOUT_SPECS, None)}
951  }
952  #[inline]
953  pub fn segment_specs(&self) -> Option<::flatbuffers::Vector<'a, SegmentSpec>> {
954    // Safety:
955    // Created from valid Table for this object
956    // which contains a valid value in this slot
957    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, SegmentSpec>>>(Footer::VT_SEGMENT_SPECS, None)}
958  }
959  #[inline]
960  pub fn compression_specs(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CompressionSpec<'a>>>> {
961    // Safety:
962    // Created from valid Table for this object
963    // which contains a valid value in this slot
964    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CompressionSpec>>>>(Footer::VT_COMPRESSION_SPECS, None)}
965  }
966  #[inline]
967  pub fn encryption_specs(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<EncryptionSpec<'a>>>> {
968    // Safety:
969    // Created from valid Table for this object
970    // which contains a valid value in this slot
971    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<EncryptionSpec>>>>(Footer::VT_ENCRYPTION_SPECS, None)}
972  }
973}
974
975impl ::flatbuffers::Verifiable for Footer<'_> {
976  #[inline]
977  fn run_verifier(
978    v: &mut ::flatbuffers::Verifier, pos: usize
979  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
980    v.visit_table(pos)?
981     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ArraySpec>>>>("array_specs", Self::VT_ARRAY_SPECS, false)?
982     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<LayoutSpec>>>>("layout_specs", Self::VT_LAYOUT_SPECS, false)?
983     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, SegmentSpec>>>("segment_specs", Self::VT_SEGMENT_SPECS, false)?
984     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<CompressionSpec>>>>("compression_specs", Self::VT_COMPRESSION_SPECS, false)?
985     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<EncryptionSpec>>>>("encryption_specs", Self::VT_ENCRYPTION_SPECS, false)?
986     .finish();
987    Ok(())
988  }
989}
990pub struct FooterArgs<'a> {
991    pub array_specs: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ArraySpec<'a>>>>>,
992    pub layout_specs: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<LayoutSpec<'a>>>>>,
993    pub segment_specs: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, SegmentSpec>>>,
994    pub compression_specs: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<CompressionSpec<'a>>>>>,
995    pub encryption_specs: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<EncryptionSpec<'a>>>>>,
996}
997impl<'a> Default for FooterArgs<'a> {
998  #[inline]
999  fn default() -> Self {
1000    FooterArgs {
1001      array_specs: None,
1002      layout_specs: None,
1003      segment_specs: None,
1004      compression_specs: None,
1005      encryption_specs: None,
1006    }
1007  }
1008}
1009
1010pub struct FooterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
1011  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
1012  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
1013}
1014impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> FooterBuilder<'a, 'b, A> {
1015  #[inline]
1016  pub fn add_array_specs(&mut self, array_specs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<ArraySpec<'b >>>>) {
1017    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Footer::VT_ARRAY_SPECS, array_specs);
1018  }
1019  #[inline]
1020  pub fn add_layout_specs(&mut self, layout_specs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<LayoutSpec<'b >>>>) {
1021    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Footer::VT_LAYOUT_SPECS, layout_specs);
1022  }
1023  #[inline]
1024  pub fn add_segment_specs(&mut self, segment_specs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , SegmentSpec>>) {
1025    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Footer::VT_SEGMENT_SPECS, segment_specs);
1026  }
1027  #[inline]
1028  pub fn add_compression_specs(&mut self, compression_specs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<CompressionSpec<'b >>>>) {
1029    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Footer::VT_COMPRESSION_SPECS, compression_specs);
1030  }
1031  #[inline]
1032  pub fn add_encryption_specs(&mut self, encryption_specs: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<EncryptionSpec<'b >>>>) {
1033    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Footer::VT_ENCRYPTION_SPECS, encryption_specs);
1034  }
1035  #[inline]
1036  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> FooterBuilder<'a, 'b, A> {
1037    let start = _fbb.start_table();
1038    FooterBuilder {
1039      fbb_: _fbb,
1040      start_: start,
1041    }
1042  }
1043  #[inline]
1044  pub fn finish(self) -> ::flatbuffers::WIPOffset<Footer<'a>> {
1045    let o = self.fbb_.end_table(self.start_);
1046    ::flatbuffers::WIPOffset::new(o.value())
1047  }
1048}
1049
1050impl ::core::fmt::Debug for Footer<'_> {
1051  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1052    let mut ds = f.debug_struct("Footer");
1053      ds.field("array_specs", &self.array_specs());
1054      ds.field("layout_specs", &self.layout_specs());
1055      ds.field("segment_specs", &self.segment_specs());
1056      ds.field("compression_specs", &self.compression_specs());
1057      ds.field("encryption_specs", &self.encryption_specs());
1058      ds.finish()
1059  }
1060}
1061pub enum ArraySpecOffset {}
1062#[derive(Copy, Clone, PartialEq)]
1063
1064/// An `ArraySpec` describes the type of a particular array.
1065///
1066/// These are identified by a globally unique string identifier, and looked up in the Vortex registry
1067/// at read-time.
1068pub struct ArraySpec<'a> {
1069  pub _tab: ::flatbuffers::Table<'a>,
1070}
1071
1072impl<'a> ::flatbuffers::Follow<'a> for ArraySpec<'a> {
1073  type Inner = ArraySpec<'a>;
1074  #[inline]
1075  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1076    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
1077  }
1078}
1079
1080impl<'a> ArraySpec<'a> {
1081  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
1082
1083  #[inline]
1084  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
1085    ArraySpec { _tab: table }
1086  }
1087  #[allow(unused_mut)]
1088  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
1089    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
1090    args: &'args ArraySpecArgs<'args>
1091  ) -> ::flatbuffers::WIPOffset<ArraySpec<'bldr>> {
1092    let mut builder = ArraySpecBuilder::new(_fbb);
1093    if let Some(x) = args.id { builder.add_id(x); }
1094    builder.finish()
1095  }
1096
1097
1098  #[inline]
1099  pub fn id(&self) -> &'a str {
1100    // Safety:
1101    // Created from valid Table for this object
1102    // which contains a valid value in this slot
1103    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(ArraySpec::VT_ID, None).unwrap()}
1104  }
1105}
1106
1107impl ::flatbuffers::Verifiable for ArraySpec<'_> {
1108  #[inline]
1109  fn run_verifier(
1110    v: &mut ::flatbuffers::Verifier, pos: usize
1111  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
1112    v.visit_table(pos)?
1113     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, true)?
1114     .finish();
1115    Ok(())
1116  }
1117}
1118pub struct ArraySpecArgs<'a> {
1119    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
1120}
1121impl<'a> Default for ArraySpecArgs<'a> {
1122  #[inline]
1123  fn default() -> Self {
1124    ArraySpecArgs {
1125      id: None, // required field
1126    }
1127  }
1128}
1129
1130pub struct ArraySpecBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
1131  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
1132  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
1133}
1134impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ArraySpecBuilder<'a, 'b, A> {
1135  #[inline]
1136  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
1137    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(ArraySpec::VT_ID, id);
1138  }
1139  #[inline]
1140  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArraySpecBuilder<'a, 'b, A> {
1141    let start = _fbb.start_table();
1142    ArraySpecBuilder {
1143      fbb_: _fbb,
1144      start_: start,
1145    }
1146  }
1147  #[inline]
1148  pub fn finish(self) -> ::flatbuffers::WIPOffset<ArraySpec<'a>> {
1149    let o = self.fbb_.end_table(self.start_);
1150    self.fbb_.required(o, ArraySpec::VT_ID,"id");
1151    ::flatbuffers::WIPOffset::new(o.value())
1152  }
1153}
1154
1155impl ::core::fmt::Debug for ArraySpec<'_> {
1156  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1157    let mut ds = f.debug_struct("ArraySpec");
1158      ds.field("id", &self.id());
1159      ds.finish()
1160  }
1161}
1162pub enum LayoutSpecOffset {}
1163#[derive(Copy, Clone, PartialEq)]
1164
1165/// A `LayoutSpec` describes the type of a particular layout.
1166///
1167/// These are identified by a globally unique string identifier, and looked up in the Vortex registry
1168/// at read-time.
1169pub struct LayoutSpec<'a> {
1170  pub _tab: ::flatbuffers::Table<'a>,
1171}
1172
1173impl<'a> ::flatbuffers::Follow<'a> for LayoutSpec<'a> {
1174  type Inner = LayoutSpec<'a>;
1175  #[inline]
1176  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1177    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
1178  }
1179}
1180
1181impl<'a> LayoutSpec<'a> {
1182  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
1183
1184  #[inline]
1185  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
1186    LayoutSpec { _tab: table }
1187  }
1188  #[allow(unused_mut)]
1189  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
1190    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
1191    args: &'args LayoutSpecArgs<'args>
1192  ) -> ::flatbuffers::WIPOffset<LayoutSpec<'bldr>> {
1193    let mut builder = LayoutSpecBuilder::new(_fbb);
1194    if let Some(x) = args.id { builder.add_id(x); }
1195    builder.finish()
1196  }
1197
1198
1199  #[inline]
1200  pub fn id(&self) -> &'a str {
1201    // Safety:
1202    // Created from valid Table for this object
1203    // which contains a valid value in this slot
1204    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(LayoutSpec::VT_ID, None).unwrap()}
1205  }
1206}
1207
1208impl ::flatbuffers::Verifiable for LayoutSpec<'_> {
1209  #[inline]
1210  fn run_verifier(
1211    v: &mut ::flatbuffers::Verifier, pos: usize
1212  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
1213    v.visit_table(pos)?
1214     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, true)?
1215     .finish();
1216    Ok(())
1217  }
1218}
1219pub struct LayoutSpecArgs<'a> {
1220    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
1221}
1222impl<'a> Default for LayoutSpecArgs<'a> {
1223  #[inline]
1224  fn default() -> Self {
1225    LayoutSpecArgs {
1226      id: None, // required field
1227    }
1228  }
1229}
1230
1231pub struct LayoutSpecBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
1232  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
1233  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
1234}
1235impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> LayoutSpecBuilder<'a, 'b, A> {
1236  #[inline]
1237  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
1238    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(LayoutSpec::VT_ID, id);
1239  }
1240  #[inline]
1241  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> LayoutSpecBuilder<'a, 'b, A> {
1242    let start = _fbb.start_table();
1243    LayoutSpecBuilder {
1244      fbb_: _fbb,
1245      start_: start,
1246    }
1247  }
1248  #[inline]
1249  pub fn finish(self) -> ::flatbuffers::WIPOffset<LayoutSpec<'a>> {
1250    let o = self.fbb_.end_table(self.start_);
1251    self.fbb_.required(o, LayoutSpec::VT_ID,"id");
1252    ::flatbuffers::WIPOffset::new(o.value())
1253  }
1254}
1255
1256impl ::core::fmt::Debug for LayoutSpec<'_> {
1257  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1258    let mut ds = f.debug_struct("LayoutSpec");
1259      ds.field("id", &self.id());
1260      ds.finish()
1261  }
1262}
1263pub enum CompressionSpecOffset {}
1264#[derive(Copy, Clone, PartialEq)]
1265
1266/// Definition of a compression scheme.
1267pub struct CompressionSpec<'a> {
1268  pub _tab: ::flatbuffers::Table<'a>,
1269}
1270
1271impl<'a> ::flatbuffers::Follow<'a> for CompressionSpec<'a> {
1272  type Inner = CompressionSpec<'a>;
1273  #[inline]
1274  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1275    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
1276  }
1277}
1278
1279impl<'a> CompressionSpec<'a> {
1280  pub const VT_SCHEME: ::flatbuffers::VOffsetT = 4;
1281
1282  #[inline]
1283  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
1284    CompressionSpec { _tab: table }
1285  }
1286  #[allow(unused_mut)]
1287  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
1288    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
1289    args: &'args CompressionSpecArgs
1290  ) -> ::flatbuffers::WIPOffset<CompressionSpec<'bldr>> {
1291    let mut builder = CompressionSpecBuilder::new(_fbb);
1292    builder.add_scheme(args.scheme);
1293    builder.finish()
1294  }
1295
1296
1297  #[inline]
1298  pub fn scheme(&self) -> CompressionScheme {
1299    // Safety:
1300    // Created from valid Table for this object
1301    // which contains a valid value in this slot
1302    unsafe { self._tab.get::<CompressionScheme>(CompressionSpec::VT_SCHEME, Some(CompressionScheme::None)).unwrap()}
1303  }
1304}
1305
1306impl ::flatbuffers::Verifiable for CompressionSpec<'_> {
1307  #[inline]
1308  fn run_verifier(
1309    v: &mut ::flatbuffers::Verifier, pos: usize
1310  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
1311    v.visit_table(pos)?
1312     .visit_field::<CompressionScheme>("scheme", Self::VT_SCHEME, false)?
1313     .finish();
1314    Ok(())
1315  }
1316}
1317pub struct CompressionSpecArgs {
1318    pub scheme: CompressionScheme,
1319}
1320impl<'a> Default for CompressionSpecArgs {
1321  #[inline]
1322  fn default() -> Self {
1323    CompressionSpecArgs {
1324      scheme: CompressionScheme::None,
1325    }
1326  }
1327}
1328
1329pub struct CompressionSpecBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
1330  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
1331  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
1332}
1333impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> CompressionSpecBuilder<'a, 'b, A> {
1334  #[inline]
1335  pub fn add_scheme(&mut self, scheme: CompressionScheme) {
1336    self.fbb_.push_slot::<CompressionScheme>(CompressionSpec::VT_SCHEME, scheme, CompressionScheme::None);
1337  }
1338  #[inline]
1339  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> CompressionSpecBuilder<'a, 'b, A> {
1340    let start = _fbb.start_table();
1341    CompressionSpecBuilder {
1342      fbb_: _fbb,
1343      start_: start,
1344    }
1345  }
1346  #[inline]
1347  pub fn finish(self) -> ::flatbuffers::WIPOffset<CompressionSpec<'a>> {
1348    let o = self.fbb_.end_table(self.start_);
1349    ::flatbuffers::WIPOffset::new(o.value())
1350  }
1351}
1352
1353impl ::core::fmt::Debug for CompressionSpec<'_> {
1354  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1355    let mut ds = f.debug_struct("CompressionSpec");
1356      ds.field("scheme", &self.scheme());
1357      ds.finish()
1358  }
1359}
1360pub enum EncryptionSpecOffset {}
1361#[derive(Copy, Clone, PartialEq)]
1362
1363pub struct EncryptionSpec<'a> {
1364  pub _tab: ::flatbuffers::Table<'a>,
1365}
1366
1367impl<'a> ::flatbuffers::Follow<'a> for EncryptionSpec<'a> {
1368  type Inner = EncryptionSpec<'a>;
1369  #[inline]
1370  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
1371    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
1372  }
1373}
1374
1375impl<'a> EncryptionSpec<'a> {
1376
1377  #[inline]
1378  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
1379    EncryptionSpec { _tab: table }
1380  }
1381  #[allow(unused_mut)]
1382  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
1383    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
1384    _args: &'args EncryptionSpecArgs
1385  ) -> ::flatbuffers::WIPOffset<EncryptionSpec<'bldr>> {
1386    let mut builder = EncryptionSpecBuilder::new(_fbb);
1387    builder.finish()
1388  }
1389
1390}
1391
1392impl ::flatbuffers::Verifiable for EncryptionSpec<'_> {
1393  #[inline]
1394  fn run_verifier(
1395    v: &mut ::flatbuffers::Verifier, pos: usize
1396  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
1397    v.visit_table(pos)?
1398     .finish();
1399    Ok(())
1400  }
1401}
1402pub struct EncryptionSpecArgs {
1403}
1404impl<'a> Default for EncryptionSpecArgs {
1405  #[inline]
1406  fn default() -> Self {
1407    EncryptionSpecArgs {
1408    }
1409  }
1410}
1411
1412pub struct EncryptionSpecBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
1413  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
1414  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
1415}
1416impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> EncryptionSpecBuilder<'a, 'b, A> {
1417  #[inline]
1418  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> EncryptionSpecBuilder<'a, 'b, A> {
1419    let start = _fbb.start_table();
1420    EncryptionSpecBuilder {
1421      fbb_: _fbb,
1422      start_: start,
1423    }
1424  }
1425  #[inline]
1426  pub fn finish(self) -> ::flatbuffers::WIPOffset<EncryptionSpec<'a>> {
1427    let o = self.fbb_.end_table(self.start_);
1428    ::flatbuffers::WIPOffset::new(o.value())
1429  }
1430}
1431
1432impl ::core::fmt::Debug for EncryptionSpec<'_> {
1433  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1434    let mut ds = f.debug_struct("EncryptionSpec");
1435      ds.finish()
1436  }
1437}
1438#[inline]
1439/// Verifies that a buffer of bytes contains a `Postscript`
1440/// and returns it.
1441/// Note that verification is still experimental and may not
1442/// catch every error, or be maximally performant. For the
1443/// previous, unchecked, behavior use
1444/// `root_as_postscript_unchecked`.
1445pub fn root_as_postscript(buf: &[u8]) -> Result<Postscript<'_>, ::flatbuffers::InvalidFlatbuffer> {
1446  ::flatbuffers::root::<Postscript>(buf)
1447}
1448#[inline]
1449/// Verifies that a buffer of bytes contains a size prefixed
1450/// `Postscript` and returns it.
1451/// Note that verification is still experimental and may not
1452/// catch every error, or be maximally performant. For the
1453/// previous, unchecked, behavior use
1454/// `size_prefixed_root_as_postscript_unchecked`.
1455pub fn size_prefixed_root_as_postscript(buf: &[u8]) -> Result<Postscript<'_>, ::flatbuffers::InvalidFlatbuffer> {
1456  ::flatbuffers::size_prefixed_root::<Postscript>(buf)
1457}
1458#[inline]
1459/// Verifies, with the given options, that a buffer of bytes
1460/// contains a `Postscript` and returns it.
1461/// Note that verification is still experimental and may not
1462/// catch every error, or be maximally performant. For the
1463/// previous, unchecked, behavior use
1464/// `root_as_postscript_unchecked`.
1465pub fn root_as_postscript_with_opts<'b, 'o>(
1466  opts: &'o ::flatbuffers::VerifierOptions,
1467  buf: &'b [u8],
1468) -> Result<Postscript<'b>, ::flatbuffers::InvalidFlatbuffer> {
1469  ::flatbuffers::root_with_opts::<Postscript<'b>>(opts, buf)
1470}
1471#[inline]
1472/// Verifies, with the given verifier options, that a buffer of
1473/// bytes contains a size prefixed `Postscript` and returns
1474/// it. Note that verification is still experimental and may not
1475/// catch every error, or be maximally performant. For the
1476/// previous, unchecked, behavior use
1477/// `root_as_postscript_unchecked`.
1478pub fn size_prefixed_root_as_postscript_with_opts<'b, 'o>(
1479  opts: &'o ::flatbuffers::VerifierOptions,
1480  buf: &'b [u8],
1481) -> Result<Postscript<'b>, ::flatbuffers::InvalidFlatbuffer> {
1482  ::flatbuffers::size_prefixed_root_with_opts::<Postscript<'b>>(opts, buf)
1483}
1484#[inline]
1485/// Assumes, without verification, that a buffer of bytes contains a Postscript and returns it.
1486/// # Safety
1487/// Callers must trust the given bytes do indeed contain a valid `Postscript`.
1488pub unsafe fn root_as_postscript_unchecked(buf: &[u8]) -> Postscript<'_> {
1489  unsafe { ::flatbuffers::root_unchecked::<Postscript>(buf) }
1490}
1491#[inline]
1492/// Assumes, without verification, that a buffer of bytes contains a size prefixed Postscript and returns it.
1493/// # Safety
1494/// Callers must trust the given bytes do indeed contain a valid size prefixed `Postscript`.
1495pub unsafe fn size_prefixed_root_as_postscript_unchecked(buf: &[u8]) -> Postscript<'_> {
1496  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Postscript>(buf) }
1497}
1498#[inline]
1499pub fn finish_postscript_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
1500    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
1501    root: ::flatbuffers::WIPOffset<Postscript<'a>>) {
1502  fbb.finish(root, None);
1503}
1504
1505#[inline]
1506pub fn finish_size_prefixed_postscript_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Postscript<'a>>) {
1507  fbb.finish_size_prefixed(root, None);
1508}
vortex_flatbuffers/generated/footer.rs

vortex_flatbuffers/generated/
footer.rs
