#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
use {
bitflags::bitflags,
fidl::{
client::QueryResponseFut,
endpoints::{ControlHandle as _, Responder as _},
},
fuchsia_zircon_status as zx_status,
futures::future::{self, MaybeDone, TryFutureExt},
};
#[cfg(target_os = "fuchsia")]
use fuchsia_zircon as zx;
pub type SensorId = i32;
pub type SensorVersion = i32;
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum SensorReportingMode {
Continuous,
OnChange,
OneShot,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u32,
},
}
#[macro_export]
macro_rules! SensorReportingModeUnknown {
() => {
_
};
}
impl SensorReportingMode {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
0 => Some(Self::Continuous),
1 => Some(Self::OnChange),
2 => Some(Self::OneShot),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u32) -> Self {
match prim {
0 => Self::Continuous,
1 => Self::OnChange,
2 => Self::OneShot,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
}
#[inline]
pub const fn into_primitive(self) -> u32 {
match self {
Self::Continuous => 0,
Self::OnChange => 1,
Self::OneShot => 2,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum SensorType {
AccelerometerUncalibrated,
GyroscopeUncalibrated,
MagneticFieldUncalibrated,
Accelerometer,
Gyroscope,
MagneticField,
Orientation,
Gravity,
LinearAcceleration,
RotationVector,
GameRotationVector,
SignificantMotion,
StepDetector,
StepCounter,
GeomagneticRotationVector,
TiltDetector,
WakeGesture,
GlanceGesture,
PickUpGesture,
WristTiltGesture,
DeviceOrientation,
Pose6Dof,
StationaryDetect,
MotionDetect,
LowLatencyOffbodyDetect,
Light,
Pressure,
Proximity,
RelativeHumidity,
AmbientTemperature,
HeartRate,
HeartBeat,
DevicePrivateBase,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u32,
},
}
#[macro_export]
macro_rules! SensorTypeUnknown {
() => {
_
};
}
impl SensorType {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
35 => Some(Self::AccelerometerUncalibrated),
16 => Some(Self::GyroscopeUncalibrated),
14 => Some(Self::MagneticFieldUncalibrated),
1 => Some(Self::Accelerometer),
4 => Some(Self::Gyroscope),
2 => Some(Self::MagneticField),
3 => Some(Self::Orientation),
9 => Some(Self::Gravity),
10 => Some(Self::LinearAcceleration),
11 => Some(Self::RotationVector),
15 => Some(Self::GameRotationVector),
17 => Some(Self::SignificantMotion),
18 => Some(Self::StepDetector),
19 => Some(Self::StepCounter),
20 => Some(Self::GeomagneticRotationVector),
22 => Some(Self::TiltDetector),
23 => Some(Self::WakeGesture),
24 => Some(Self::GlanceGesture),
25 => Some(Self::PickUpGesture),
26 => Some(Self::WristTiltGesture),
27 => Some(Self::DeviceOrientation),
28 => Some(Self::Pose6Dof),
29 => Some(Self::StationaryDetect),
30 => Some(Self::MotionDetect),
34 => Some(Self::LowLatencyOffbodyDetect),
5 => Some(Self::Light),
6 => Some(Self::Pressure),
8 => Some(Self::Proximity),
12 => Some(Self::RelativeHumidity),
13 => Some(Self::AmbientTemperature),
21 => Some(Self::HeartRate),
31 => Some(Self::HeartBeat),
65536 => Some(Self::DevicePrivateBase),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u32) -> Self {
match prim {
35 => Self::AccelerometerUncalibrated,
16 => Self::GyroscopeUncalibrated,
14 => Self::MagneticFieldUncalibrated,
1 => Self::Accelerometer,
4 => Self::Gyroscope,
2 => Self::MagneticField,
3 => Self::Orientation,
9 => Self::Gravity,
10 => Self::LinearAcceleration,
11 => Self::RotationVector,
15 => Self::GameRotationVector,
17 => Self::SignificantMotion,
18 => Self::StepDetector,
19 => Self::StepCounter,
20 => Self::GeomagneticRotationVector,
22 => Self::TiltDetector,
23 => Self::WakeGesture,
24 => Self::GlanceGesture,
25 => Self::PickUpGesture,
26 => Self::WristTiltGesture,
27 => Self::DeviceOrientation,
28 => Self::Pose6Dof,
29 => Self::StationaryDetect,
30 => Self::MotionDetect,
34 => Self::LowLatencyOffbodyDetect,
5 => Self::Light,
6 => Self::Pressure,
8 => Self::Proximity,
12 => Self::RelativeHumidity,
13 => Self::AmbientTemperature,
21 => Self::HeartRate,
31 => Self::HeartBeat,
65536 => Self::DevicePrivateBase,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
}
#[inline]
pub const fn into_primitive(self) -> u32 {
match self {
Self::AccelerometerUncalibrated => 35,
Self::GyroscopeUncalibrated => 16,
Self::MagneticFieldUncalibrated => 14,
Self::Accelerometer => 1,
Self::Gyroscope => 4,
Self::MagneticField => 2,
Self::Orientation => 3,
Self::Gravity => 9,
Self::LinearAcceleration => 10,
Self::RotationVector => 11,
Self::GameRotationVector => 15,
Self::SignificantMotion => 17,
Self::StepDetector => 18,
Self::StepCounter => 19,
Self::GeomagneticRotationVector => 20,
Self::TiltDetector => 22,
Self::WakeGesture => 23,
Self::GlanceGesture => 24,
Self::PickUpGesture => 25,
Self::WristTiltGesture => 26,
Self::DeviceOrientation => 27,
Self::Pose6Dof => 28,
Self::StationaryDetect => 29,
Self::MotionDetect => 30,
Self::LowLatencyOffbodyDetect => 34,
Self::Light => 5,
Self::Pressure => 6,
Self::Proximity => 8,
Self::RelativeHumidity => 12,
Self::AmbientTemperature => 13,
Self::HeartRate => 21,
Self::HeartBeat => 31,
Self::DevicePrivateBase => 65536,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum SensorWakeUpType {
NonWakeUp,
WakeUp,
#[doc(hidden)]
__SourceBreaking {
unknown_ordinal: u32,
},
}
#[macro_export]
macro_rules! SensorWakeUpTypeUnknown {
() => {
_
};
}
impl SensorWakeUpType {
#[inline]
pub fn from_primitive(prim: u32) -> Option<Self> {
match prim {
0 => Some(Self::NonWakeUp),
1 => Some(Self::WakeUp),
_ => None,
}
}
#[inline]
pub fn from_primitive_allow_unknown(prim: u32) -> Self {
match prim {
0 => Self::NonWakeUp,
1 => Self::WakeUp,
unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
}
}
#[inline]
pub fn unknown() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
}
#[inline]
pub const fn into_primitive(self) -> u32 {
match self {
Self::NonWakeUp => 0,
Self::WakeUp => 1,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { unknown_ordinal: _ } => true,
_ => false,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Pose {
pub rotation: fidl_fuchsia_math::Vec4F,
pub translation: fidl_fuchsia_math::Vec3F,
pub rotation_delta: fidl_fuchsia_math::Vec4F,
pub translation_delta: fidl_fuchsia_math::Vec3F,
}
impl fidl::Persistable for Pose {}
#[derive(Clone, Debug, PartialEq)]
pub struct SensorEvent {
pub timestamp: i64,
pub sensor_id: i32,
pub sensor_type: SensorType,
pub sequence_number: u64,
pub payload: EventPayload,
}
impl fidl::Persistable for SensorEvent {}
#[derive(Clone, Debug, PartialEq)]
pub struct UncalibratedVec3FSample {
pub sample: fidl_fuchsia_math::Vec3F,
pub biases: fidl_fuchsia_math::Vec3F,
}
impl fidl::Persistable for UncalibratedVec3FSample {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SensorInfo {
pub sensor_id: Option<i32>,
pub name: Option<String>,
pub vendor: Option<String>,
pub version: Option<i32>,
pub sensor_type: Option<SensorType>,
pub wake_up: Option<SensorWakeUpType>,
pub reporting_mode: Option<SensorReportingMode>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for SensorInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SensorRateConfig {
pub sampling_period_ns: Option<i64>,
pub max_reporting_latency_ns: Option<i64>,
#[doc(hidden)]
pub __source_breaking: fidl::marker::SourceBreaking,
}
impl fidl::Persistable for SensorRateConfig {}
#[derive(Clone, Debug)]
pub enum EventPayload {
Vec3(fidl_fuchsia_math::Vec3F),
Quaternion(fidl_fuchsia_math::Vec4F),
UncalibratedVec3(UncalibratedVec3FSample),
Float(f32),
Integer(u64),
Pose(Pose),
#[doc(hidden)]
__SourceBreaking { unknown_ordinal: u64 },
}
#[macro_export]
macro_rules! EventPayloadUnknown {
() => {
_
};
}
impl PartialEq for EventPayload {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(Self::Vec3(x), Self::Vec3(y)) => *x == *y,
(Self::Quaternion(x), Self::Quaternion(y)) => *x == *y,
(Self::UncalibratedVec3(x), Self::UncalibratedVec3(y)) => *x == *y,
(Self::Float(x), Self::Float(y)) => *x == *y,
(Self::Integer(x), Self::Integer(y)) => *x == *y,
(Self::Pose(x), Self::Pose(y)) => *x == *y,
_ => false,
}
}
}
impl EventPayload {
#[inline]
pub fn ordinal(&self) -> u64 {
match *self {
Self::Vec3(_) => 1,
Self::Quaternion(_) => 2,
Self::UncalibratedVec3(_) => 3,
Self::Float(_) => 4,
Self::Integer(_) => 5,
Self::Pose(_) => 6,
Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
}
}
#[inline]
pub fn unknown_variant_for_testing() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0 }
}
#[inline]
pub fn is_unknown(&self) -> bool {
match self {
Self::__SourceBreaking { .. } => true,
_ => false,
}
}
}
impl fidl::Persistable for EventPayload {}
mod internal {
use super::*;
unsafe impl fidl::encoding::TypeMarker for SensorReportingMode {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for SensorReportingMode {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for SensorReportingMode {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SensorReportingMode {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for SensorType {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for SensorType {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for SensorType {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SensorType {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for SensorWakeUpType {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u32>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u32>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
false
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for SensorWakeUpType {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for SensorWakeUpType {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SensorWakeUpType {
#[inline(always)]
fn new_empty() -> Self {
Self::unknown()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_primitive_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for Pose {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
56
}
}
impl fidl::encoding::ValueTypeMarker for Pose {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<Pose> for &Pose {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Pose>(offset);
fidl::encoding::Encode::<Pose>::encode(
(
<fidl_fuchsia_math::Vec4F as fidl::encoding::ValueTypeMarker>::borrow(
&self.rotation,
),
<fidl_fuchsia_math::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
&self.translation,
),
<fidl_fuchsia_math::Vec4F as fidl::encoding::ValueTypeMarker>::borrow(
&self.rotation_delta,
),
<fidl_fuchsia_math::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
&self.translation_delta,
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl_fuchsia_math::Vec4F>,
T1: fidl::encoding::Encode<fidl_fuchsia_math::Vec3F>,
T2: fidl::encoding::Encode<fidl_fuchsia_math::Vec4F>,
T3: fidl::encoding::Encode<fidl_fuchsia_math::Vec3F>,
> fidl::encoding::Encode<Pose> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Pose>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
self.2.encode(encoder, offset + 28, depth)?;
self.3.encode(encoder, offset + 44, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for Pose {
#[inline(always)]
fn new_empty() -> Self {
Self {
rotation: fidl::new_empty!(fidl_fuchsia_math::Vec4F),
translation: fidl::new_empty!(fidl_fuchsia_math::Vec3F),
rotation_delta: fidl::new_empty!(fidl_fuchsia_math::Vec4F),
translation_delta: fidl::new_empty!(fidl_fuchsia_math::Vec3F),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl_fuchsia_math::Vec4F,
&mut self.rotation,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl_fuchsia_math::Vec3F,
&mut self.translation,
decoder,
offset + 16,
_depth
)?;
fidl::decode!(
fidl_fuchsia_math::Vec4F,
&mut self.rotation_delta,
decoder,
offset + 28,
_depth
)?;
fidl::decode!(
fidl_fuchsia_math::Vec3F,
&mut self.translation_delta,
decoder,
offset + 44,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for SensorEvent {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
40
}
}
impl fidl::encoding::ValueTypeMarker for SensorEvent {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<SensorEvent> for &SensorEvent {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<SensorEvent>(offset);
fidl::encoding::Encode::<SensorEvent>::encode(
(
<i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp),
<i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.sensor_id),
<SensorType as fidl::encoding::ValueTypeMarker>::borrow(&self.sensor_type),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.sequence_number),
<EventPayload as fidl::encoding::ValueTypeMarker>::borrow(&self.payload),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<i64>,
T1: fidl::encoding::Encode<i32>,
T2: fidl::encoding::Encode<SensorType>,
T3: fidl::encoding::Encode<u64>,
T4: fidl::encoding::Encode<EventPayload>,
> fidl::encoding::Encode<SensorEvent> for (T0, T1, T2, T3, T4)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<SensorEvent>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
self.2.encode(encoder, offset + 12, depth)?;
self.3.encode(encoder, offset + 16, depth)?;
self.4.encode(encoder, offset + 24, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SensorEvent {
#[inline(always)]
fn new_empty() -> Self {
Self {
timestamp: fidl::new_empty!(i64),
sensor_id: fidl::new_empty!(i32),
sensor_type: fidl::new_empty!(SensorType),
sequence_number: fidl::new_empty!(u64),
payload: fidl::new_empty!(EventPayload),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(i64, &mut self.timestamp, decoder, offset + 0, _depth)?;
fidl::decode!(i32, &mut self.sensor_id, decoder, offset + 8, _depth)?;
fidl::decode!(SensorType, &mut self.sensor_type, decoder, offset + 12, _depth)?;
fidl::decode!(u64, &mut self.sequence_number, decoder, offset + 16, _depth)?;
fidl::decode!(EventPayload, &mut self.payload, decoder, offset + 24, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for UncalibratedVec3FSample {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
24
}
}
impl fidl::encoding::ValueTypeMarker for UncalibratedVec3FSample {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<UncalibratedVec3FSample> for &UncalibratedVec3FSample {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<UncalibratedVec3FSample>(offset);
fidl::encoding::Encode::<UncalibratedVec3FSample>::encode(
(
<fidl_fuchsia_math::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
&self.sample,
),
<fidl_fuchsia_math::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
&self.biases,
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl_fuchsia_math::Vec3F>,
T1: fidl::encoding::Encode<fidl_fuchsia_math::Vec3F>,
> fidl::encoding::Encode<UncalibratedVec3FSample> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<UncalibratedVec3FSample>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 12, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for UncalibratedVec3FSample {
#[inline(always)]
fn new_empty() -> Self {
Self {
sample: fidl::new_empty!(fidl_fuchsia_math::Vec3F),
biases: fidl::new_empty!(fidl_fuchsia_math::Vec3F),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl_fuchsia_math::Vec3F, &mut self.sample, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl_fuchsia_math::Vec3F,
&mut self.biases,
decoder,
offset + 12,
_depth
)?;
Ok(())
}
}
impl SensorInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.reporting_mode {
return 7;
}
if let Some(_) = self.wake_up {
return 6;
}
if let Some(_) = self.sensor_type {
return 5;
}
if let Some(_) = self.version {
return 4;
}
if let Some(_) = self.vendor {
return 3;
}
if let Some(_) = self.name {
return 2;
}
if let Some(_) = self.sensor_id {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for SensorInfo {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ValueTypeMarker for SensorInfo {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<SensorInfo> for &SensorInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<SensorInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<i32>(
self.sensor_id.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.name.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.vendor.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<i32>(
self.version.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<SensorType>(
self.sensor_type
.as_ref()
.map(<SensorType as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 6 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (6 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<SensorWakeUpType>(
self.wake_up
.as_ref()
.map(<SensorWakeUpType as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 7 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (7 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<SensorReportingMode>(
self.reporting_mode
.as_ref()
.map(<SensorReportingMode as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SensorInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.sensor_id.get_or_insert_with(|| fidl::new_empty!(i32));
fidl::decode!(i32, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.vendor
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(i32));
fidl::decode!(i32, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<SensorType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.sensor_type.get_or_insert_with(|| fidl::new_empty!(SensorType));
fidl::decode!(SensorType, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 6 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<SensorWakeUpType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.wake_up.get_or_insert_with(|| fidl::new_empty!(SensorWakeUpType));
fidl::decode!(SensorWakeUpType, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 7 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<SensorReportingMode as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.reporting_mode
.get_or_insert_with(|| fidl::new_empty!(SensorReportingMode));
fidl::decode!(SensorReportingMode, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl SensorRateConfig {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.max_reporting_latency_ns {
return 2;
}
if let Some(_) = self.sampling_period_ns {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for SensorRateConfig {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ValueTypeMarker for SensorRateConfig {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<SensorRateConfig> for &SensorRateConfig {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<SensorRateConfig>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<i64>(
self.sampling_period_ns
.as_ref()
.map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<i64>(
self.max_reporting_latency_ns
.as_ref()
.map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SensorRateConfig {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
if len == 0 {
return Ok(());
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.sampling_period_ns.get_or_insert_with(|| fidl::new_empty!(i64));
fidl::decode!(i64, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.max_reporting_latency_ns.get_or_insert_with(|| fidl::new_empty!(i64));
fidl::decode!(i64, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for EventPayload {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ValueTypeMarker for EventPayload {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<EventPayload> for &EventPayload {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<EventPayload>(offset);
encoder.write_num::<u64>(self.ordinal(), offset);
match self {
EventPayload::Vec3(ref val) => {
fidl::encoding::encode_in_envelope::<fidl_fuchsia_math::Vec3F>(
<fidl_fuchsia_math::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder,
offset + 8,
_depth,
)
}
EventPayload::Quaternion(ref val) => {
fidl::encoding::encode_in_envelope::<fidl_fuchsia_math::Vec4F>(
<fidl_fuchsia_math::Vec4F as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder,
offset + 8,
_depth,
)
}
EventPayload::UncalibratedVec3(ref val) => {
fidl::encoding::encode_in_envelope::<UncalibratedVec3FSample>(
<UncalibratedVec3FSample as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder,
offset + 8,
_depth,
)
}
EventPayload::Float(ref val) => fidl::encoding::encode_in_envelope::<f32>(
<f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder,
offset + 8,
_depth,
),
EventPayload::Integer(ref val) => fidl::encoding::encode_in_envelope::<u64>(
<u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder,
offset + 8,
_depth,
),
EventPayload::Pose(ref val) => fidl::encoding::encode_in_envelope::<Pose>(
<Pose as fidl::encoding::ValueTypeMarker>::borrow(val),
encoder,
offset + 8,
_depth,
),
EventPayload::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
}
}
}
impl fidl::encoding::Decode<Self> for EventPayload {
#[inline(always)]
fn new_empty() -> Self {
Self::__SourceBreaking { unknown_ordinal: 0 }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
#[allow(unused_variables)]
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
let (ordinal, inlined, num_bytes, num_handles) =
fidl::encoding::decode_union_inline_portion(decoder, offset)?;
let member_inline_size = match ordinal {
1 => <fidl_fuchsia_math::Vec3F as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
),
2 => <fidl_fuchsia_math::Vec4F as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
),
3 => <UncalibratedVec3FSample as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
),
4 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6 => <Pose as fidl::encoding::TypeMarker>::inline_size(decoder.context),
0 => return Err(fidl::Error::UnknownUnionTag),
_ => num_bytes as usize,
};
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let _inner_offset;
if inlined {
decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
_inner_offset = offset + 8;
} else {
depth.increment()?;
_inner_offset = decoder.out_of_line_offset(member_inline_size)?;
}
match ordinal {
1 => {
#[allow(irrefutable_let_patterns)]
if let EventPayload::Vec3(_) = self {
} else {
*self = EventPayload::Vec3(fidl::new_empty!(fidl_fuchsia_math::Vec3F));
}
#[allow(irrefutable_let_patterns)]
if let EventPayload::Vec3(ref mut val) = self {
fidl::decode!(
fidl_fuchsia_math::Vec3F,
val,
decoder,
_inner_offset,
depth
)?;
} else {
unreachable!()
}
}
2 => {
#[allow(irrefutable_let_patterns)]
if let EventPayload::Quaternion(_) = self {
} else {
*self =
EventPayload::Quaternion(fidl::new_empty!(fidl_fuchsia_math::Vec4F));
}
#[allow(irrefutable_let_patterns)]
if let EventPayload::Quaternion(ref mut val) = self {
fidl::decode!(
fidl_fuchsia_math::Vec4F,
val,
decoder,
_inner_offset,
depth
)?;
} else {
unreachable!()
}
}
3 => {
#[allow(irrefutable_let_patterns)]
if let EventPayload::UncalibratedVec3(_) = self {
} else {
*self = EventPayload::UncalibratedVec3(fidl::new_empty!(
UncalibratedVec3FSample
));
}
#[allow(irrefutable_let_patterns)]
if let EventPayload::UncalibratedVec3(ref mut val) = self {
fidl::decode!(UncalibratedVec3FSample, val, decoder, _inner_offset, depth)?;
} else {
unreachable!()
}
}
4 => {
#[allow(irrefutable_let_patterns)]
if let EventPayload::Float(_) = self {
} else {
*self = EventPayload::Float(fidl::new_empty!(f32));
}
#[allow(irrefutable_let_patterns)]
if let EventPayload::Float(ref mut val) = self {
fidl::decode!(f32, val, decoder, _inner_offset, depth)?;
} else {
unreachable!()
}
}
5 => {
#[allow(irrefutable_let_patterns)]
if let EventPayload::Integer(_) = self {
} else {
*self = EventPayload::Integer(fidl::new_empty!(u64));
}
#[allow(irrefutable_let_patterns)]
if let EventPayload::Integer(ref mut val) = self {
fidl::decode!(u64, val, decoder, _inner_offset, depth)?;
} else {
unreachable!()
}
}
6 => {
#[allow(irrefutable_let_patterns)]
if let EventPayload::Pose(_) = self {
} else {
*self = EventPayload::Pose(fidl::new_empty!(Pose));
}
#[allow(irrefutable_let_patterns)]
if let EventPayload::Pose(ref mut val) = self {
fidl::decode!(Pose, val, decoder, _inner_offset, depth)?;
} else {
unreachable!()
}
}
#[allow(deprecated)]
ordinal => {
for _ in 0..num_handles {
decoder.drop_next_handle()?;
}
*self = EventPayload::__SourceBreaking { unknown_ordinal: ordinal };
}
}
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
Ok(())
}
}
}