...

Text file src/github.com/google/flatbuffers/goldens/rust/basic_generated.rs

Documentation: github.com/google/flatbuffers/goldens/rust

     1// automatically generated by the FlatBuffers compiler, do not modify
     2
     3
     4// @generated
     5
     6use core::mem;
     7use core::cmp::Ordering;
     8
     9extern crate flatbuffers;
    10use self::flatbuffers::{EndianScalar, Follow};
    11
    12pub enum GalaxyOffset {}
    13#[derive(Copy, Clone, PartialEq)]
    14
    15pub struct Galaxy<'a> {
    16  pub _tab: flatbuffers::Table<'a>,
    17}
    18
    19impl<'a> flatbuffers::Follow<'a> for Galaxy<'a> {
    20  type Inner = Galaxy<'a>;
    21  #[inline]
    22  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    23    Self { _tab: flatbuffers::Table::new(buf, loc) }
    24  }
    25}
    26
    27impl<'a> Galaxy<'a> {
    28  pub const VT_NUM_STARS: flatbuffers::VOffsetT = 4;
    29
    30  #[inline]
    31  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    32    Galaxy { _tab: table }
    33  }
    34  #[allow(unused_mut)]
    35  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
    36    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
    37    args: &'args GalaxyArgs
    38  ) -> flatbuffers::WIPOffset<Galaxy<'bldr>> {
    39    let mut builder = GalaxyBuilder::new(_fbb);
    40    builder.add_num_stars(args.num_stars);
    41    builder.finish()
    42  }
    43
    44
    45  #[inline]
    46  pub fn num_stars(&self) -> i64 {
    47    // Safety:
    48    // Created from valid Table for this object
    49    // which contains a valid value in this slot
    50    unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
    51  }
    52}
    53
    54impl flatbuffers::Verifiable for Galaxy<'_> {
    55  #[inline]
    56  fn run_verifier(
    57    v: &mut flatbuffers::Verifier, pos: usize
    58  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    59    use self::flatbuffers::Verifiable;
    60    v.visit_table(pos)?
    61     .visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
    62     .finish();
    63    Ok(())
    64  }
    65}
    66pub struct GalaxyArgs {
    67    pub num_stars: i64,
    68}
    69impl<'a> Default for GalaxyArgs {
    70  #[inline]
    71  fn default() -> Self {
    72    GalaxyArgs {
    73      num_stars: 0,
    74    }
    75  }
    76}
    77
    78pub struct GalaxyBuilder<'a: 'b, 'b> {
    79  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
    80  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
    81}
    82impl<'a: 'b, 'b> GalaxyBuilder<'a, 'b> {
    83  #[inline]
    84  pub fn add_num_stars(&mut self, num_stars: i64) {
    85    self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
    86  }
    87  #[inline]
    88  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> GalaxyBuilder<'a, 'b> {
    89    let start = _fbb.start_table();
    90    GalaxyBuilder {
    91      fbb_: _fbb,
    92      start_: start,
    93    }
    94  }
    95  #[inline]
    96  pub fn finish(self) -> flatbuffers::WIPOffset<Galaxy<'a>> {
    97    let o = self.fbb_.end_table(self.start_);
    98    flatbuffers::WIPOffset::new(o.value())
    99  }
   100}
   101
   102impl core::fmt::Debug for Galaxy<'_> {
   103  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
   104    let mut ds = f.debug_struct("Galaxy");
   105      ds.field("num_stars", &self.num_stars());
   106      ds.finish()
   107  }
   108}
   109pub enum UniverseOffset {}
   110#[derive(Copy, Clone, PartialEq)]
   111
   112pub struct Universe<'a> {
   113  pub _tab: flatbuffers::Table<'a>,
   114}
   115
   116impl<'a> flatbuffers::Follow<'a> for Universe<'a> {
   117  type Inner = Universe<'a>;
   118  #[inline]
   119  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
   120    Self { _tab: flatbuffers::Table::new(buf, loc) }
   121  }
   122}
   123
   124impl<'a> Universe<'a> {
   125  pub const VT_AGE: flatbuffers::VOffsetT = 4;
   126  pub const VT_GALAXIES: flatbuffers::VOffsetT = 6;
   127
   128  #[inline]
   129  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
   130    Universe { _tab: table }
   131  }
   132  #[allow(unused_mut)]
   133  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
   134    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
   135    args: &'args UniverseArgs<'args>
   136  ) -> flatbuffers::WIPOffset<Universe<'bldr>> {
   137    let mut builder = UniverseBuilder::new(_fbb);
   138    builder.add_age(args.age);
   139    if let Some(x) = args.galaxies { builder.add_galaxies(x); }
   140    builder.finish()
   141  }
   142
   143
   144  #[inline]
   145  pub fn age(&self) -> f64 {
   146    // Safety:
   147    // Created from valid Table for this object
   148    // which contains a valid value in this slot
   149    unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
   150  }
   151  #[inline]
   152  pub fn galaxies(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
   153    // Safety:
   154    // Created from valid Table for this object
   155    // which contains a valid value in this slot
   156    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
   157  }
   158}
   159
   160impl flatbuffers::Verifiable for Universe<'_> {
   161  #[inline]
   162  fn run_verifier(
   163    v: &mut flatbuffers::Verifier, pos: usize
   164  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
   165    use self::flatbuffers::Verifiable;
   166    v.visit_table(pos)?
   167     .visit_field::<f64>("age", Self::VT_AGE, false)?
   168     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
   169     .finish();
   170    Ok(())
   171  }
   172}
   173pub struct UniverseArgs<'a> {
   174    pub age: f64,
   175    pub galaxies: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
   176}
   177impl<'a> Default for UniverseArgs<'a> {
   178  #[inline]
   179  fn default() -> Self {
   180    UniverseArgs {
   181      age: 0.0,
   182      galaxies: None,
   183    }
   184  }
   185}
   186
   187pub struct UniverseBuilder<'a: 'b, 'b> {
   188  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
   189  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
   190}
   191impl<'a: 'b, 'b> UniverseBuilder<'a, 'b> {
   192  #[inline]
   193  pub fn add_age(&mut self, age: f64) {
   194    self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
   195  }
   196  #[inline]
   197  pub fn add_galaxies(&mut self, galaxies: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
   198    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
   199  }
   200  #[inline]
   201  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> UniverseBuilder<'a, 'b> {
   202    let start = _fbb.start_table();
   203    UniverseBuilder {
   204      fbb_: _fbb,
   205      start_: start,
   206    }
   207  }
   208  #[inline]
   209  pub fn finish(self) -> flatbuffers::WIPOffset<Universe<'a>> {
   210    let o = self.fbb_.end_table(self.start_);
   211    flatbuffers::WIPOffset::new(o.value())
   212  }
   213}
   214
   215impl core::fmt::Debug for Universe<'_> {
   216  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
   217    let mut ds = f.debug_struct("Universe");
   218      ds.field("age", &self.age());
   219      ds.field("galaxies", &self.galaxies());
   220      ds.finish()
   221  }
   222}
   223#[inline]
   224/// Verifies that a buffer of bytes contains a `Universe`
   225/// and returns it.
   226/// Note that verification is still experimental and may not
   227/// catch every error, or be maximally performant. For the
   228/// previous, unchecked, behavior use
   229/// `root_as_universe_unchecked`.
   230pub fn root_as_universe(buf: &[u8]) -> Result<Universe, flatbuffers::InvalidFlatbuffer> {
   231  flatbuffers::root::<Universe>(buf)
   232}
   233#[inline]
   234/// Verifies that a buffer of bytes contains a size prefixed
   235/// `Universe` and returns it.
   236/// Note that verification is still experimental and may not
   237/// catch every error, or be maximally performant. For the
   238/// previous, unchecked, behavior use
   239/// `size_prefixed_root_as_universe_unchecked`.
   240pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe, flatbuffers::InvalidFlatbuffer> {
   241  flatbuffers::size_prefixed_root::<Universe>(buf)
   242}
   243#[inline]
   244/// Verifies, with the given options, that a buffer of bytes
   245/// contains a `Universe` and returns it.
   246/// Note that verification is still experimental and may not
   247/// catch every error, or be maximally performant. For the
   248/// previous, unchecked, behavior use
   249/// `root_as_universe_unchecked`.
   250pub fn root_as_universe_with_opts<'b, 'o>(
   251  opts: &'o flatbuffers::VerifierOptions,
   252  buf: &'b [u8],
   253) -> Result<Universe<'b>, flatbuffers::InvalidFlatbuffer> {
   254  flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
   255}
   256#[inline]
   257/// Verifies, with the given verifier options, that a buffer of
   258/// bytes contains a size prefixed `Universe` and returns
   259/// it. Note that verification is still experimental and may not
   260/// catch every error, or be maximally performant. For the
   261/// previous, unchecked, behavior use
   262/// `root_as_universe_unchecked`.
   263pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
   264  opts: &'o flatbuffers::VerifierOptions,
   265  buf: &'b [u8],
   266) -> Result<Universe<'b>, flatbuffers::InvalidFlatbuffer> {
   267  flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
   268}
   269#[inline]
   270/// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
   271/// # Safety
   272/// Callers must trust the given bytes do indeed contain a valid `Universe`.
   273pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe {
   274  flatbuffers::root_unchecked::<Universe>(buf)
   275}
   276#[inline]
   277/// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
   278/// # Safety
   279/// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
   280pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe {
   281  flatbuffers::size_prefixed_root_unchecked::<Universe>(buf)
   282}
   283#[inline]
   284pub fn finish_universe_buffer<'a, 'b>(
   285    fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
   286    root: flatbuffers::WIPOffset<Universe<'a>>) {
   287  fbb.finish(root, None);
   288}
   289
   290#[inline]
   291pub fn finish_size_prefixed_universe_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<Universe<'a>>) {
   292  fbb.finish_size_prefixed(root, None);
   293}

View as plain text