vortex_file/flatbuffers/generated/
footer.rs

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

vortex_file/flatbuffers/generated/
footer.rs
