SensorFrame_generated.rs

// automatically generated by the FlatBuffers compiler, do not modify
// @generated
extern crate alloc;


#[allow(unused_imports, dead_code)]
pub mod cpss {

#[allow(unused_imports, dead_code)]
pub mod tom {

#[allow(unused_imports, dead_code)]
pub mod sensord {


// struct SensorFrameData, aligned to 8
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct SensorFrameData(pub [u8; 80]);
impl Default for SensorFrameData { 
  fn default() -> Self { 
    Self([0; 80])
  }
}
impl ::core::fmt::Debug for SensorFrameData {
  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
    f.debug_struct("SensorFrameData")
      .field("gyro_x", &self.gyro_x())
      .field("gyro_y", &self.gyro_y())
      .field("gyro_z", &self.gyro_z())
      .field("accel_x", &self.accel_x())
      .field("accel_y", &self.accel_y())
      .field("accel_z", &self.accel_z())
      .field("temperature", &self.temperature())
      .field("pressure", &self.pressure())
      .field("altitude", &self.altitude())
      .field("speed", &self.speed())
      .field("heading", &self.heading())
      .field("latitude", &self.latitude())
      .field("longitude", &self.longitude())
      .field("estimated_speed_error", &self.estimated_speed_error())
      .field("estimated_latitude_error", &self.estimated_latitude_error())
      .field("estimated_longitude_error", &self.estimated_longitude_error())
      .field("satellites", &self.satellites())
      .field("valid_satellites", &self.valid_satellites())
      .finish()
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for SensorFrameData {}
impl<'a> ::flatbuffers::Follow<'a> for SensorFrameData {
  type Inner = &'a SensorFrameData;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { <&'a SensorFrameData>::follow(buf, loc) }
  }
}
impl<'a> ::flatbuffers::Follow<'a> for &'a SensorFrameData {
  type Inner = &'a SensorFrameData;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { ::flatbuffers::follow_cast_ref::<SensorFrameData>(buf, loc) }
  }
}
impl<'b> ::flatbuffers::Push for SensorFrameData {
    type Output = SensorFrameData;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        let src = unsafe { ::core::slice::from_raw_parts(self as *const SensorFrameData as *const u8, <Self as ::flatbuffers::Push>::size()) };
        dst.copy_from_slice(src);
    }
    #[inline]
    fn alignment() -> ::flatbuffers::PushAlignment {
        ::flatbuffers::PushAlignment::new(8)
    }
}

impl<'a> ::flatbuffers::Verifiable for SensorFrameData {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.in_buffer::<Self>(pos)
  }
}

impl<'a> SensorFrameData {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    gyro_x: f32,
    gyro_y: f32,
    gyro_z: f32,
    accel_x: f32,
    accel_y: f32,
    accel_z: f32,
    temperature: f32,
    pressure: f32,
    altitude: f32,
    speed: f32,
    heading: f32,
    latitude: f64,
    longitude: f64,
    estimated_speed_error: f32,
    estimated_latitude_error: f32,
    estimated_longitude_error: f32,
    satellites: u8,
    valid_satellites: u8,
  ) -> Self {
    let mut s = Self([0; 80]);
    s.set_gyro_x(gyro_x);
    s.set_gyro_y(gyro_y);
    s.set_gyro_z(gyro_z);
    s.set_accel_x(accel_x);
    s.set_accel_y(accel_y);
    s.set_accel_z(accel_z);
    s.set_temperature(temperature);
    s.set_pressure(pressure);
    s.set_altitude(altitude);
    s.set_speed(speed);
    s.set_heading(heading);
    s.set_latitude(latitude);
    s.set_longitude(longitude);
    s.set_estimated_speed_error(estimated_speed_error);
    s.set_estimated_latitude_error(estimated_latitude_error);
    s.set_estimated_longitude_error(estimated_longitude_error);
    s.set_satellites(satellites);
    s.set_valid_satellites(valid_satellites);
    s
  }

  pub fn gyro_x(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[0..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_gyro_x(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[0..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn gyro_y(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[4..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_gyro_y(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[4..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn gyro_z(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[8..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_gyro_z(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[8..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn accel_x(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[12..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_accel_x(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[12..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn accel_y(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[16..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_accel_y(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[16..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn accel_z(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[20..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_accel_z(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[20..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn temperature(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[24..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_temperature(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[24..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn pressure(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[28..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_pressure(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[28..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn altitude(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[32..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_altitude(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[32..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn speed(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[36..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_speed(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[36..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn heading(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[40..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_heading(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[40..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn latitude(&self) -> f64 {
    let mut mem = ::core::mem::MaybeUninit::<<f64 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[48..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_latitude(&mut self, x: f64) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[48..].as_mut_ptr(),
        ::core::mem::size_of::<<f64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn longitude(&self) -> f64 {
    let mut mem = ::core::mem::MaybeUninit::<<f64 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[56..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_longitude(&mut self, x: f64) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[56..].as_mut_ptr(),
        ::core::mem::size_of::<<f64 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn estimated_speed_error(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[64..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_estimated_speed_error(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[64..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn estimated_latitude_error(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[68..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_estimated_latitude_error(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[68..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn estimated_longitude_error(&self) -> f32 {
    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[72..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_estimated_longitude_error(&mut self, x: f32) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[72..].as_mut_ptr(),
        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn satellites(&self) -> u8 {
    let mut mem = ::core::mem::MaybeUninit::<<u8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[76..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_satellites(&mut self, x: u8) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[76..].as_mut_ptr(),
        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

  pub fn valid_satellites(&self) -> u8 {
    let mut mem = ::core::mem::MaybeUninit::<<u8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
      ::core::ptr::copy_nonoverlapping(
        self.0[77..].as_ptr(),
        mem.as_mut_ptr() as *mut u8,
        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
      mem.assume_init()
    })
  }

  pub fn set_valid_satellites(&mut self, x: u8) {
    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid value in this slot
    unsafe {
      ::core::ptr::copy_nonoverlapping(
        &x_le as *const _ as *const u8,
        self.0[77..].as_mut_ptr(),
        ::core::mem::size_of::<<u8 as ::flatbuffers::EndianScalar>::Scalar>(),
      );
    }
  }

}

pub enum SensorFrameOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct SensorFrame<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for SensorFrame<'a> {
  type Inner = SensorFrame<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> SensorFrame<'a> {
  pub const VT_DATA: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    SensorFrame { _tab: table }
  }
  #[allow(unused_mut)]
  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
    args: &'args SensorFrameArgs<'args>
  ) -> ::flatbuffers::WIPOffset<SensorFrame<'bldr>> {
    let mut builder = SensorFrameBuilder::new(_fbb);
    if let Some(x) = args.data { builder.add_data(x); }
    builder.finish()
  }


  #[inline]
  pub fn data(&self) -> Option<&'a SensorFrameData> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<SensorFrameData>(SensorFrame::VT_DATA, None)}
  }
}

impl ::flatbuffers::Verifiable for SensorFrame<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<SensorFrameData>("data", Self::VT_DATA, false)?
     .finish();
    Ok(())
  }
}
pub struct SensorFrameArgs<'a> {
    pub data: Option<&'a SensorFrameData>,
}
impl<'a> Default for SensorFrameArgs<'a> {
  #[inline]
  fn default() -> Self {
    SensorFrameArgs {
      data: None,
    }
  }
}

pub struct SensorFrameBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SensorFrameBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_data(&mut self, data: &SensorFrameData) {
    self.fbb_.push_slot_always::<&SensorFrameData>(SensorFrame::VT_DATA, data);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SensorFrameBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SensorFrameBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<SensorFrame<'a>> {
    let o = self.fbb_.end_table(self.start_);
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for SensorFrame<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("SensorFrame");
      ds.field("data", &self.data());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `SensorFrame`
/// and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_sensor_frame_unchecked`.
pub fn root_as_sensor_frame(buf: &[u8]) -> Result<SensorFrame<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<SensorFrame>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `SensorFrame` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `size_prefixed_root_as_sensor_frame_unchecked`.
pub fn size_prefixed_root_as_sensor_frame(buf: &[u8]) -> Result<SensorFrame<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<SensorFrame>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `SensorFrame` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_sensor_frame_unchecked`.
pub fn root_as_sensor_frame_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<SensorFrame<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<SensorFrame<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `SensorFrame` and returns
/// it. Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_sensor_frame_unchecked`.
pub fn size_prefixed_root_as_sensor_frame_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<SensorFrame<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<SensorFrame<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a SensorFrame and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `SensorFrame`.
pub unsafe fn root_as_sensor_frame_unchecked(buf: &[u8]) -> SensorFrame<'_> {
  unsafe { ::flatbuffers::root_unchecked::<SensorFrame>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed SensorFrame and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `SensorFrame`.
pub unsafe fn size_prefixed_root_as_sensor_frame_unchecked(buf: &[u8]) -> SensorFrame<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<SensorFrame>(buf) }
}
#[inline]
pub fn finish_sensor_frame_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<SensorFrame<'a>>) {
  fbb.finish(root, None);
}

#[inline]
pub fn finish_size_prefixed_sensor_frame_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<SensorFrame<'a>>) {
  fbb.finish_size_prefixed(root, None);
}
}  // pub mod sensord
}  // pub mod tom
}  // pub mod cpss