Google Git
Sign in
fuchsia / fuchsia / main / . / tools / fidl / fidlgen_rust_next / goldens / padding_common.rs.golden
blob: 366fa0f2b97a53086aa657435548e8431d61a8cd [file] [log] [blame]
// DO NOT EDIT: This file is machine-generated by fidlgen
#![warn(clippy::all)]
#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
pub mod natural {
#[derive(PartialEq, Clone, Debug)]
pub struct Padding1ByteEnd {
pub a: u16,
pub b: u8,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding1ByteEnd, ___E> for Padding1ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding1ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding1ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding1ByteEnd, ___E>
for &'a Padding1ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding1ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding1ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding1ByteEnd>, ___E>
for Padding1ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
Padding1ByteEnd: ::fidl_next::Encode<crate::wire::Padding1ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding1ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding1ByteEnd>, ___E>
for &'a Padding1ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding1ByteEnd: ::fidl_next::Encode<crate::wire::Padding1ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding1ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding1ByteEnd> for Padding1ByteEnd {
#[inline]
fn from_wire(wire: crate::wire::Padding1ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding1ByteEnd> for Padding1ByteEnd {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding1ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding1ByteMiddle {
pub a: u8,
pub b: u16,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding1ByteMiddle, ___E> for Padding1ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding1ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding1ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding1ByteMiddle, ___E>
for &'a Padding1ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding1ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding1ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding1ByteMiddle>,
___E,
> for Padding1ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
Padding1ByteMiddle: ::fidl_next::Encode<crate::wire::Padding1ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding1ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding1ByteMiddle>,
___E,
> for &'a Padding1ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding1ByteMiddle: ::fidl_next::Encode<crate::wire::Padding1ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding1ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding1ByteMiddle> for Padding1ByteMiddle {
#[inline]
fn from_wire(wire: crate::wire::Padding1ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding1ByteMiddle> for Padding1ByteMiddle {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding1ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding2ByteAlignmentLength6 {
pub a: u8,
pub b: u16,
pub c: u8,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding2ByteAlignmentLength6, ___E>
for Padding2ByteAlignmentLength6
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteAlignmentLength6>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteAlignmentLength6 {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding2ByteAlignmentLength6, ___E>
for &'a Padding2ByteAlignmentLength6
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteAlignmentLength6>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteAlignmentLength6 {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteAlignmentLength6>,
___E,
> for Padding2ByteAlignmentLength6
where
___E: ::fidl_next::Encoder + ?Sized,
Padding2ByteAlignmentLength6:
::fidl_next::Encode<crate::wire::Padding2ByteAlignmentLength6, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteAlignmentLength6>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteAlignmentLength6>,
___E,
> for &'a Padding2ByteAlignmentLength6
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding2ByteAlignmentLength6:
::fidl_next::Encode<crate::wire::Padding2ByteAlignmentLength6, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteAlignmentLength6>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding2ByteAlignmentLength6>
for Padding2ByteAlignmentLength6
{
#[inline]
fn from_wire(wire: crate::wire::Padding2ByteAlignmentLength6) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
c: ::fidl_next::FromWire::from_wire(wire.c),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding2ByteAlignmentLength6>
for Padding2ByteAlignmentLength6
{
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding2ByteAlignmentLength6) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
c: ::fidl_next::FromWireRef::from_wire_ref(&wire.c),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding2ByteEnd {
pub a: u32,
pub b: u16,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding2ByteEnd, ___E> for Padding2ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding2ByteEnd, ___E>
for &'a Padding2ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding2ByteEnd>, ___E>
for Padding2ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
Padding2ByteEnd: ::fidl_next::Encode<crate::wire::Padding2ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding2ByteEnd>, ___E>
for &'a Padding2ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding2ByteEnd: ::fidl_next::Encode<crate::wire::Padding2ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding2ByteEnd> for Padding2ByteEnd {
#[inline]
fn from_wire(wire: crate::wire::Padding2ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding2ByteEnd> for Padding2ByteEnd {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding2ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding2ByteMiddle {
pub a: u16,
pub b: u32,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding2ByteMiddle, ___E> for Padding2ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding2ByteMiddle, ___E>
for &'a Padding2ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteMiddle>,
___E,
> for Padding2ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
Padding2ByteMiddle: ::fidl_next::Encode<crate::wire::Padding2ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteMiddle>,
___E,
> for &'a Padding2ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding2ByteMiddle: ::fidl_next::Encode<crate::wire::Padding2ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding2ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding2ByteMiddle> for Padding2ByteMiddle {
#[inline]
fn from_wire(wire: crate::wire::Padding2ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding2ByteMiddle> for Padding2ByteMiddle {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding2ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding3ByteEnd {
pub a: u32,
pub b: u8,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding3ByteEnd, ___E> for Padding3ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding3ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding3ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding3ByteEnd, ___E>
for &'a Padding3ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding3ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding3ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding3ByteEnd>, ___E>
for Padding3ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
Padding3ByteEnd: ::fidl_next::Encode<crate::wire::Padding3ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding3ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding3ByteEnd>, ___E>
for &'a Padding3ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding3ByteEnd: ::fidl_next::Encode<crate::wire::Padding3ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding3ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding3ByteEnd> for Padding3ByteEnd {
#[inline]
fn from_wire(wire: crate::wire::Padding3ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding3ByteEnd> for Padding3ByteEnd {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding3ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding3ByteMiddle {
pub a: u8,
pub b: u32,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding3ByteMiddle, ___E> for Padding3ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding3ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding3ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding3ByteMiddle, ___E>
for &'a Padding3ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding3ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding3ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding3ByteMiddle>,
___E,
> for Padding3ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
Padding3ByteMiddle: ::fidl_next::Encode<crate::wire::Padding3ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding3ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding3ByteMiddle>,
___E,
> for &'a Padding3ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding3ByteMiddle: ::fidl_next::Encode<crate::wire::Padding3ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding3ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding3ByteMiddle> for Padding3ByteMiddle {
#[inline]
fn from_wire(wire: crate::wire::Padding3ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding3ByteMiddle> for Padding3ByteMiddle {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding3ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding4ByteAlignmentLength12 {
pub a: u32,
pub b: u8,
pub c: u16,
pub d: u16,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding4ByteAlignmentLength12, ___E>
for Padding4ByteAlignmentLength12
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteAlignmentLength12>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteAlignmentLength12 {
a,
b,
c,
d,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
::fidl_next::Encode::encode(self.d, encoder_, d, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(d.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding4ByteAlignmentLength12, ___E>
for &'a Padding4ByteAlignmentLength12
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteAlignmentLength12>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteAlignmentLength12 {
a,
b,
c,
d,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.d, encoder_, d, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(d.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteAlignmentLength12>,
___E,
> for Padding4ByteAlignmentLength12
where
___E: ::fidl_next::Encoder + ?Sized,
Padding4ByteAlignmentLength12:
::fidl_next::Encode<crate::wire::Padding4ByteAlignmentLength12, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteAlignmentLength12>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteAlignmentLength12>,
___E,
> for &'a Padding4ByteAlignmentLength12
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding4ByteAlignmentLength12:
::fidl_next::Encode<crate::wire::Padding4ByteAlignmentLength12, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteAlignmentLength12>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding4ByteAlignmentLength12>
for Padding4ByteAlignmentLength12
{
#[inline]
fn from_wire(wire: crate::wire::Padding4ByteAlignmentLength12) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
c: ::fidl_next::FromWire::from_wire(wire.c),
d: ::fidl_next::FromWire::from_wire(wire.d),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding4ByteAlignmentLength12>
for Padding4ByteAlignmentLength12
{
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding4ByteAlignmentLength12) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
c: ::fidl_next::FromWireRef::from_wire_ref(&wire.c),
d: ::fidl_next::FromWireRef::from_wire_ref(&wire.d),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding4ByteEnd {
pub a: u64,
pub b: u32,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding4ByteEnd, ___E> for Padding4ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding4ByteEnd, ___E>
for &'a Padding4ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding4ByteEnd>, ___E>
for Padding4ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
Padding4ByteEnd: ::fidl_next::Encode<crate::wire::Padding4ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding4ByteEnd>, ___E>
for &'a Padding4ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding4ByteEnd: ::fidl_next::Encode<crate::wire::Padding4ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding4ByteEnd> for Padding4ByteEnd {
#[inline]
fn from_wire(wire: crate::wire::Padding4ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding4ByteEnd> for Padding4ByteEnd {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding4ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding4ByteMiddle {
pub a: u32,
pub b: u64,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding4ByteMiddle, ___E> for Padding4ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding4ByteMiddle, ___E>
for &'a Padding4ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteMiddle>,
___E,
> for Padding4ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
Padding4ByteMiddle: ::fidl_next::Encode<crate::wire::Padding4ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteMiddle>,
___E,
> for &'a Padding4ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding4ByteMiddle: ::fidl_next::Encode<crate::wire::Padding4ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding4ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding4ByteMiddle> for Padding4ByteMiddle {
#[inline]
fn from_wire(wire: crate::wire::Padding4ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding4ByteMiddle> for Padding4ByteMiddle {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding4ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding5ByteEnd {
pub a: u64,
pub b: u16,
pub c: u8,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding5ByteEnd, ___E> for Padding5ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding5ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding5ByteEnd {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding5ByteEnd, ___E>
for &'a Padding5ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding5ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding5ByteEnd {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding5ByteEnd>, ___E>
for Padding5ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
Padding5ByteEnd: ::fidl_next::Encode<crate::wire::Padding5ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding5ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding5ByteEnd>, ___E>
for &'a Padding5ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding5ByteEnd: ::fidl_next::Encode<crate::wire::Padding5ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding5ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding5ByteEnd> for Padding5ByteEnd {
#[inline]
fn from_wire(wire: crate::wire::Padding5ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
c: ::fidl_next::FromWire::from_wire(wire.c),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding5ByteEnd> for Padding5ByteEnd {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding5ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
c: ::fidl_next::FromWireRef::from_wire_ref(&wire.c),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding5ByteMiddle {
pub a: u16,
pub b: u8,
pub c: u64,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding5ByteMiddle, ___E> for Padding5ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding5ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding5ByteMiddle {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding5ByteMiddle, ___E>
for &'a Padding5ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding5ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding5ByteMiddle {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.c, encoder_, c, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(c.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding5ByteMiddle>,
___E,
> for Padding5ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
Padding5ByteMiddle: ::fidl_next::Encode<crate::wire::Padding5ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding5ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding5ByteMiddle>,
___E,
> for &'a Padding5ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding5ByteMiddle: ::fidl_next::Encode<crate::wire::Padding5ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding5ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding5ByteMiddle> for Padding5ByteMiddle {
#[inline]
fn from_wire(wire: crate::wire::Padding5ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
c: ::fidl_next::FromWire::from_wire(wire.c),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding5ByteMiddle> for Padding5ByteMiddle {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding5ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
c: ::fidl_next::FromWireRef::from_wire_ref(&wire.c),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding6ByteEnd {
pub a: u64,
pub b: u16,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding6ByteEnd, ___E> for Padding6ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding6ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding6ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding6ByteEnd, ___E>
for &'a Padding6ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding6ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding6ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding6ByteEnd>, ___E>
for Padding6ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
Padding6ByteEnd: ::fidl_next::Encode<crate::wire::Padding6ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding6ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding6ByteEnd>, ___E>
for &'a Padding6ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding6ByteEnd: ::fidl_next::Encode<crate::wire::Padding6ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding6ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding6ByteEnd> for Padding6ByteEnd {
#[inline]
fn from_wire(wire: crate::wire::Padding6ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding6ByteEnd> for Padding6ByteEnd {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding6ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding6ByteMiddle {
pub a: u16,
pub b: u64,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding6ByteMiddle, ___E> for Padding6ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding6ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding6ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding6ByteMiddle, ___E>
for &'a Padding6ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding6ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding6ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding6ByteMiddle>,
___E,
> for Padding6ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
Padding6ByteMiddle: ::fidl_next::Encode<crate::wire::Padding6ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding6ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding6ByteMiddle>,
___E,
> for &'a Padding6ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding6ByteMiddle: ::fidl_next::Encode<crate::wire::Padding6ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding6ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding6ByteMiddle> for Padding6ByteMiddle {
#[inline]
fn from_wire(wire: crate::wire::Padding6ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding6ByteMiddle> for Padding6ByteMiddle {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding6ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding7ByteEnd {
pub a: u64,
pub b: u8,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding7ByteEnd, ___E> for Padding7ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding7ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding7ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding7ByteEnd, ___E>
for &'a Padding7ByteEnd
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding7ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding7ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding7ByteEnd>, ___E>
for Padding7ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
Padding7ByteEnd: ::fidl_next::Encode<crate::wire::Padding7ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding7ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<::fidl_next::WireBox<'static, crate::wire::Padding7ByteEnd>, ___E>
for &'a Padding7ByteEnd
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding7ByteEnd: ::fidl_next::Encode<crate::wire::Padding7ByteEnd, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding7ByteEnd>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding7ByteEnd> for Padding7ByteEnd {
#[inline]
fn from_wire(wire: crate::wire::Padding7ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding7ByteEnd> for Padding7ByteEnd {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding7ByteEnd) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
#[derive(PartialEq, Clone, Debug)]
pub struct Padding7ByteMiddle {
pub a: u8,
pub b: u64,
}
unsafe impl<___E> ::fidl_next::Encode<crate::wire::Padding7ByteMiddle, ___E> for Padding7ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding7ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding7ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Padding7ByteMiddle, ___E>
for &'a Padding7ByteMiddle
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding7ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding7ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(&self.a, encoder_, a, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(a.as_mut_ptr()) };
::fidl_next::Encode::encode(&self.b, encoder_, b, ())?;
let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(b.as_mut_ptr()) };
Ok(())
}
}
unsafe impl<___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding7ByteMiddle>,
___E,
> for Padding7ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
Padding7ByteMiddle: ::fidl_next::Encode<crate::wire::Padding7ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding7ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
unsafe impl<'a, ___E>
::fidl_next::EncodeOption<
::fidl_next::WireBox<'static, crate::wire::Padding7ByteMiddle>,
___E,
> for &'a Padding7ByteMiddle
where
___E: ::fidl_next::Encoder + ?Sized,
&'a Padding7ByteMiddle: ::fidl_next::Encode<crate::wire::Padding7ByteMiddle, ___E>,
{
#[inline]
fn encode_option(
this: ::core::option::Option<Self>,
encoder: &mut ___E,
out: &mut ::core::mem::MaybeUninit<
::fidl_next::WireBox<'static, crate::wire::Padding7ByteMiddle>,
>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
if let Some(inner) = this {
::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
::fidl_next::WireBox::encode_present(out);
} else {
::fidl_next::WireBox::encode_absent(out);
}
Ok(())
}
}
impl ::fidl_next::FromWire<crate::wire::Padding7ByteMiddle> for Padding7ByteMiddle {
#[inline]
fn from_wire(wire: crate::wire::Padding7ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWire::from_wire(wire.a),
b: ::fidl_next::FromWire::from_wire(wire.b),
}
}
}
impl ::fidl_next::FromWireRef<crate::wire::Padding7ByteMiddle> for Padding7ByteMiddle {
#[inline]
fn from_wire_ref(wire: &crate::wire::Padding7ByteMiddle) -> Self {
Self {
a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),
b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
}
}
}
}
pub mod wire {
/// The wire type corresponding to [`Padding1ByteEnd`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding1ByteEnd {
pub a: ::fidl_next::WireU16,
pub b: u8,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding1ByteEnd>(), 4);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding1ByteEnd>(), 2);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding1ByteEnd, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding1ByteEnd, b), 2);
unsafe impl ::fidl_next::Wire for Padding1ByteEnd {
type Owned<'de> = Padding1ByteEnd;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(3).write_bytes(0, 1);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding1ByteEnd
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[3..4] != [0u8; 1] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding1ByteEnd {
type Natural = crate::natural::Padding1ByteEnd;
}
impl ::fidl_next::Unconstrained for Padding1ByteEnd {}
/// The wire type corresponding to [`Padding1ByteMiddle`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding1ByteMiddle {
pub a: u8,
pub b: ::fidl_next::WireU16,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding1ByteMiddle>(), 4);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding1ByteMiddle>(), 2);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding1ByteMiddle, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding1ByteMiddle, b), 2);
unsafe impl ::fidl_next::Wire for Padding1ByteMiddle {
type Owned<'de> = Padding1ByteMiddle;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 1);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding1ByteMiddle
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[1..2] != [0u8; 1] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding1ByteMiddle {
type Natural = crate::natural::Padding1ByteMiddle;
}
impl ::fidl_next::Unconstrained for Padding1ByteMiddle {}
/// The wire type corresponding to [`Padding2ByteAlignmentLength6`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding2ByteAlignmentLength6 {
pub a: u8,
pub b: ::fidl_next::WireU16,
pub c: u8,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding2ByteAlignmentLength6>(), 6);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding2ByteAlignmentLength6>(), 2);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding2ByteAlignmentLength6, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding2ByteAlignmentLength6, b), 2);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding2ByteAlignmentLength6, c), 4);
unsafe impl ::fidl_next::Wire for Padding2ByteAlignmentLength6 {
type Owned<'de> = Padding2ByteAlignmentLength6;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
c,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
::fidl_next::Wire::zero_padding(c);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(5).write_bytes(0, 1);
}
unsafe {
out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 1);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding2ByteAlignmentLength6
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[5..6] != [0u8; 1] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
if slot_.as_bytes()[1..2] != [0u8; 1] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
mut c,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
let _field = c.as_mut();
::fidl_next::Decode::decode(c.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding2ByteAlignmentLength6 {
type Natural = crate::natural::Padding2ByteAlignmentLength6;
}
impl ::fidl_next::Unconstrained for Padding2ByteAlignmentLength6 {}
/// The wire type corresponding to [`Padding2ByteEnd`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding2ByteEnd {
pub a: ::fidl_next::WireU32,
pub b: ::fidl_next::WireU16,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding2ByteEnd>(), 8);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding2ByteEnd>(), 4);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding2ByteEnd, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding2ByteEnd, b), 4);
unsafe impl ::fidl_next::Wire for Padding2ByteEnd {
type Owned<'de> = Padding2ByteEnd;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(6).write_bytes(0, 2);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding2ByteEnd
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[6..8] != [0u8; 2] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding2ByteEnd {
type Natural = crate::natural::Padding2ByteEnd;
}
impl ::fidl_next::Unconstrained for Padding2ByteEnd {}
/// The wire type corresponding to [`Padding2ByteMiddle`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding2ByteMiddle {
pub a: ::fidl_next::WireU16,
pub b: ::fidl_next::WireU32,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding2ByteMiddle>(), 8);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding2ByteMiddle>(), 4);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding2ByteMiddle, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding2ByteMiddle, b), 4);
unsafe impl ::fidl_next::Wire for Padding2ByteMiddle {
type Owned<'de> = Padding2ByteMiddle;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(2).write_bytes(0, 2);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding2ByteMiddle
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[2..4] != [0u8; 2] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding2ByteMiddle {
type Natural = crate::natural::Padding2ByteMiddle;
}
impl ::fidl_next::Unconstrained for Padding2ByteMiddle {}
/// The wire type corresponding to [`Padding3ByteEnd`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding3ByteEnd {
pub a: ::fidl_next::WireU32,
pub b: u8,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding3ByteEnd>(), 8);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding3ByteEnd>(), 4);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding3ByteEnd, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding3ByteEnd, b), 4);
unsafe impl ::fidl_next::Wire for Padding3ByteEnd {
type Owned<'de> = Padding3ByteEnd;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(5).write_bytes(0, 3);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding3ByteEnd
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[5..8] != [0u8; 3] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding3ByteEnd {
type Natural = crate::natural::Padding3ByteEnd;
}
impl ::fidl_next::Unconstrained for Padding3ByteEnd {}
/// The wire type corresponding to [`Padding3ByteMiddle`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding3ByteMiddle {
pub a: u8,
pub b: ::fidl_next::WireU32,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding3ByteMiddle>(), 8);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding3ByteMiddle>(), 4);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding3ByteMiddle, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding3ByteMiddle, b), 4);
unsafe impl ::fidl_next::Wire for Padding3ByteMiddle {
type Owned<'de> = Padding3ByteMiddle;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 3);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding3ByteMiddle
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[1..4] != [0u8; 3] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding3ByteMiddle {
type Natural = crate::natural::Padding3ByteMiddle;
}
impl ::fidl_next::Unconstrained for Padding3ByteMiddle {}
/// The wire type corresponding to [`Padding4ByteAlignmentLength12`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding4ByteAlignmentLength12 {
pub a: ::fidl_next::WireU32,
pub b: u8,
pub c: ::fidl_next::WireU16,
pub d: ::fidl_next::WireU16,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding4ByteAlignmentLength12>(), 12);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding4ByteAlignmentLength12>(), 4);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteAlignmentLength12, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteAlignmentLength12, b), 4);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteAlignmentLength12, c), 6);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteAlignmentLength12, d), 8);
unsafe impl ::fidl_next::Wire for Padding4ByteAlignmentLength12 {
type Owned<'de> = Padding4ByteAlignmentLength12;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
c,
d,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
::fidl_next::Wire::zero_padding(c);
::fidl_next::Wire::zero_padding(d);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(10).write_bytes(0, 2);
}
unsafe {
out_.as_mut_ptr().cast::<u8>().add(5).write_bytes(0, 1);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding4ByteAlignmentLength12
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[10..12] != [0u8; 2] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
if slot_.as_bytes()[5..6] != [0u8; 1] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
mut c,
mut d,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
let _field = c.as_mut();
::fidl_next::Decode::decode(c.as_mut(), decoder_, ())?;
let _field = d.as_mut();
::fidl_next::Decode::decode(d.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding4ByteAlignmentLength12 {
type Natural = crate::natural::Padding4ByteAlignmentLength12;
}
impl ::fidl_next::Unconstrained for Padding4ByteAlignmentLength12 {}
/// The wire type corresponding to [`Padding4ByteEnd`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding4ByteEnd {
pub a: ::fidl_next::WireU64,
pub b: ::fidl_next::WireU32,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding4ByteEnd>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding4ByteEnd>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteEnd, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteEnd, b), 8);
unsafe impl ::fidl_next::Wire for Padding4ByteEnd {
type Owned<'de> = Padding4ByteEnd;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding4ByteEnd
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[12..16] != [0u8; 4] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding4ByteEnd {
type Natural = crate::natural::Padding4ByteEnd;
}
impl ::fidl_next::Unconstrained for Padding4ByteEnd {}
/// The wire type corresponding to [`Padding4ByteMiddle`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding4ByteMiddle {
pub a: ::fidl_next::WireU32,
pub b: ::fidl_next::WireU64,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding4ByteMiddle>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding4ByteMiddle>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteMiddle, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding4ByteMiddle, b), 8);
unsafe impl ::fidl_next::Wire for Padding4ByteMiddle {
type Owned<'de> = Padding4ByteMiddle;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding4ByteMiddle
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[4..8] != [0u8; 4] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding4ByteMiddle {
type Natural = crate::natural::Padding4ByteMiddle;
}
impl ::fidl_next::Unconstrained for Padding4ByteMiddle {}
/// The wire type corresponding to [`Padding5ByteEnd`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding5ByteEnd {
pub a: ::fidl_next::WireU64,
pub b: ::fidl_next::WireU16,
pub c: u8,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding5ByteEnd>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding5ByteEnd>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding5ByteEnd, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding5ByteEnd, b), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding5ByteEnd, c), 10);
unsafe impl ::fidl_next::Wire for Padding5ByteEnd {
type Owned<'de> = Padding5ByteEnd;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
c,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
::fidl_next::Wire::zero_padding(c);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(11).write_bytes(0, 5);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding5ByteEnd
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[11..16] != [0u8; 5] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
mut c,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
let _field = c.as_mut();
::fidl_next::Decode::decode(c.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding5ByteEnd {
type Natural = crate::natural::Padding5ByteEnd;
}
impl ::fidl_next::Unconstrained for Padding5ByteEnd {}
/// The wire type corresponding to [`Padding5ByteMiddle`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding5ByteMiddle {
pub a: ::fidl_next::WireU16,
pub b: u8,
pub c: ::fidl_next::WireU64,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding5ByteMiddle>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding5ByteMiddle>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding5ByteMiddle, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding5ByteMiddle, b), 2);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding5ByteMiddle, c), 8);
unsafe impl ::fidl_next::Wire for Padding5ByteMiddle {
type Owned<'de> = Padding5ByteMiddle;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
c,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
::fidl_next::Wire::zero_padding(c);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(3).write_bytes(0, 5);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding5ByteMiddle
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[3..8] != [0u8; 5] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
mut c,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
let _field = c.as_mut();
::fidl_next::Decode::decode(c.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding5ByteMiddle {
type Natural = crate::natural::Padding5ByteMiddle;
}
impl ::fidl_next::Unconstrained for Padding5ByteMiddle {}
/// The wire type corresponding to [`Padding6ByteEnd`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding6ByteEnd {
pub a: ::fidl_next::WireU64,
pub b: ::fidl_next::WireU16,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding6ByteEnd>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding6ByteEnd>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding6ByteEnd, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding6ByteEnd, b), 8);
unsafe impl ::fidl_next::Wire for Padding6ByteEnd {
type Owned<'de> = Padding6ByteEnd;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(10).write_bytes(0, 6);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding6ByteEnd
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[10..16] != [0u8; 6] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding6ByteEnd {
type Natural = crate::natural::Padding6ByteEnd;
}
impl ::fidl_next::Unconstrained for Padding6ByteEnd {}
/// The wire type corresponding to [`Padding6ByteMiddle`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding6ByteMiddle {
pub a: ::fidl_next::WireU16,
pub b: ::fidl_next::WireU64,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding6ByteMiddle>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding6ByteMiddle>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding6ByteMiddle, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding6ByteMiddle, b), 8);
unsafe impl ::fidl_next::Wire for Padding6ByteMiddle {
type Owned<'de> = Padding6ByteMiddle;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(2).write_bytes(0, 6);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding6ByteMiddle
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[2..8] != [0u8; 6] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding6ByteMiddle {
type Natural = crate::natural::Padding6ByteMiddle;
}
impl ::fidl_next::Unconstrained for Padding6ByteMiddle {}
/// The wire type corresponding to [`Padding7ByteEnd`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding7ByteEnd {
pub a: ::fidl_next::WireU64,
pub b: u8,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding7ByteEnd>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding7ByteEnd>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding7ByteEnd, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding7ByteEnd, b), 8);
unsafe impl ::fidl_next::Wire for Padding7ByteEnd {
type Owned<'de> = Padding7ByteEnd;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(9).write_bytes(0, 7);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding7ByteEnd
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[9..16] != [0u8; 7] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding7ByteEnd {
type Natural = crate::natural::Padding7ByteEnd;
}
impl ::fidl_next::Unconstrained for Padding7ByteEnd {}
/// The wire type corresponding to [`Padding7ByteMiddle`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct Padding7ByteMiddle {
pub a: u8,
pub b: ::fidl_next::WireU64,
}
static_assertions::const_assert_eq!(std::mem::size_of::<Padding7ByteMiddle>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<Padding7ByteMiddle>(), 8);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding7ByteMiddle, a), 0);
static_assertions::const_assert_eq!(std::mem::offset_of!(Padding7ByteMiddle, b), 8);
unsafe impl ::fidl_next::Wire for Padding7ByteMiddle {
type Owned<'de> = Padding7ByteMiddle;
#[inline]
fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
::fidl_next::munge! {
let Self {
a,
b,
} = &mut *out_;
}
::fidl_next::Wire::zero_padding(a);
::fidl_next::Wire::zero_padding(b);
unsafe {
out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 7);
}
}
}
unsafe impl<___D> ::fidl_next::Decode<___D> for Padding7ByteMiddle
where
___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
fn decode(
slot_: ::fidl_next::Slot<'_, Self>,
decoder_: &mut ___D,
_: (),
) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
if slot_.as_bytes()[1..8] != [0u8; 7] {
return Err(::fidl_next::DecodeError::InvalidPadding);
}
::fidl_next::munge! {
let Self {
mut a,
mut b,
} = slot_;
}
let _field = a.as_mut();
::fidl_next::Decode::decode(a.as_mut(), decoder_, ())?;
let _field = b.as_mut();
::fidl_next::Decode::decode(b.as_mut(), decoder_, ())?;
Ok(())
}
}
impl ::fidl_next::IntoNatural for Padding7ByteMiddle {
type Natural = crate::natural::Padding7ByteMiddle;
}
impl ::fidl_next::Unconstrained for Padding7ByteMiddle {}
}
pub mod wire_optional {}
pub mod generic {
pub struct Padding1ByteEnd<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding1ByteEnd, ___E>
for Padding1ByteEnd<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
T1: ::fidl_next::Encode<u8, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding1ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding1ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding1ByteMiddle<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding1ByteMiddle, ___E>
for Padding1ByteMiddle<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<u8, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding1ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding1ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding2ByteAlignmentLength6<T0, T1, T2> {
pub a: T0,
pub b: T1,
pub c: T2,
}
unsafe impl<___E, T0, T1, T2>
::fidl_next::Encode<crate::wire::Padding2ByteAlignmentLength6, ___E>
for Padding2ByteAlignmentLength6<T0, T1, T2>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<u8, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
T2: ::fidl_next::Encode<u8, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteAlignmentLength6>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteAlignmentLength6 {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
Ok(())
}
}
pub struct Padding2ByteEnd<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding2ByteEnd, ___E>
for Padding2ByteEnd<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding2ByteMiddle<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding2ByteMiddle, ___E>
for Padding2ByteMiddle<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding2ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding2ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding3ByteEnd<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding3ByteEnd, ___E>
for Padding3ByteEnd<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
T1: ::fidl_next::Encode<u8, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding3ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding3ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding3ByteMiddle<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding3ByteMiddle, ___E>
for Padding3ByteMiddle<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<u8, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding3ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding3ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding4ByteAlignmentLength12<T0, T1, T2, T3> {
pub a: T0,
pub b: T1,
pub c: T2,
pub d: T3,
}
unsafe impl<___E, T0, T1, T2, T3>
::fidl_next::Encode<crate::wire::Padding4ByteAlignmentLength12, ___E>
for Padding4ByteAlignmentLength12<T0, T1, T2, T3>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
T1: ::fidl_next::Encode<u8, ___E>,
T2: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
T3: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteAlignmentLength12>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteAlignmentLength12 {
a,
b,
c,
d,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
::fidl_next::Encode::encode(self.d, encoder_, d, ())?;
Ok(())
}
}
pub struct Padding4ByteEnd<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding4ByteEnd, ___E>
for Padding4ByteEnd<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding4ByteMiddle<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding4ByteMiddle, ___E>
for Padding4ByteMiddle<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU32, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding4ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding4ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding5ByteEnd<T0, T1, T2> {
pub a: T0,
pub b: T1,
pub c: T2,
}
unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Padding5ByteEnd, ___E>
for Padding5ByteEnd<T0, T1, T2>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
T2: ::fidl_next::Encode<u8, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding5ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding5ByteEnd {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
Ok(())
}
}
pub struct Padding5ByteMiddle<T0, T1, T2> {
pub a: T0,
pub b: T1,
pub c: T2,
}
unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::Padding5ByteMiddle, ___E>
for Padding5ByteMiddle<T0, T1, T2>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
T1: ::fidl_next::Encode<u8, ___E>,
T2: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding5ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding5ByteMiddle {
a,
b,
c,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
::fidl_next::Encode::encode(self.c, encoder_, c, ())?;
Ok(())
}
}
pub struct Padding6ByteEnd<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding6ByteEnd, ___E>
for Padding6ByteEnd<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding6ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding6ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding6ByteMiddle<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding6ByteMiddle, ___E>
for Padding6ByteMiddle<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU16, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding6ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding6ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding7ByteEnd<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding7ByteEnd, ___E>
for Padding7ByteEnd<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
T1: ::fidl_next::Encode<u8, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding7ByteEnd>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding7ByteEnd {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
pub struct Padding7ByteMiddle<T0, T1> {
pub a: T0,
pub b: T1,
}
unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::Padding7ByteMiddle, ___E>
for Padding7ByteMiddle<T0, T1>
where
___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
T0: ::fidl_next::Encode<u8, ___E>,
T1: ::fidl_next::Encode<::fidl_next::WireU64, ___E>,
{
#[inline]
fn encode(
self,
encoder_: &mut ___E,
out_: &mut ::core::mem::MaybeUninit<crate::wire::Padding7ByteMiddle>,
_: (),
) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
::fidl_next::munge! {
let crate::wire::Padding7ByteMiddle {
a,
b,
} = out_;
}
::fidl_next::Encode::encode(self.a, encoder_, a, ())?;
::fidl_next::Encode::encode(self.b, encoder_, b, ())?;
Ok(())
}
}
}
pub use self::natural::*;
/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {
impl ::fidl_next::CompatFrom<crate::Padding1ByteEnd> for ::fidl_test_padding::Padding1ByteEnd {
#[inline]
fn compat_from(value: crate::Padding1ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding1ByteEnd> for crate::Padding1ByteEnd {
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding1ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding1ByteMiddle>
for ::fidl_test_padding::Padding1ByteMiddle
{
#[inline]
fn compat_from(value: crate::Padding1ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding1ByteMiddle>
for crate::Padding1ByteMiddle
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding1ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding2ByteAlignmentLength6>
for ::fidl_test_padding::Padding2ByteAlignmentLength6
{
#[inline]
fn compat_from(value: crate::Padding2ByteAlignmentLength6) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding2ByteAlignmentLength6>
for crate::Padding2ByteAlignmentLength6
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding2ByteAlignmentLength6) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding2ByteEnd> for ::fidl_test_padding::Padding2ByteEnd {
#[inline]
fn compat_from(value: crate::Padding2ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding2ByteEnd> for crate::Padding2ByteEnd {
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding2ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding2ByteMiddle>
for ::fidl_test_padding::Padding2ByteMiddle
{
#[inline]
fn compat_from(value: crate::Padding2ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding2ByteMiddle>
for crate::Padding2ByteMiddle
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding2ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding3ByteEnd> for ::fidl_test_padding::Padding3ByteEnd {
#[inline]
fn compat_from(value: crate::Padding3ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding3ByteEnd> for crate::Padding3ByteEnd {
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding3ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding3ByteMiddle>
for ::fidl_test_padding::Padding3ByteMiddle
{
#[inline]
fn compat_from(value: crate::Padding3ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding3ByteMiddle>
for crate::Padding3ByteMiddle
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding3ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding4ByteAlignmentLength12>
for ::fidl_test_padding::Padding4ByteAlignmentLength12
{
#[inline]
fn compat_from(value: crate::Padding4ByteAlignmentLength12) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
d: ::fidl_next::CompatFrom::compat_from(value.d),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding4ByteAlignmentLength12>
for crate::Padding4ByteAlignmentLength12
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding4ByteAlignmentLength12) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
d: ::fidl_next::CompatFrom::compat_from(value.d),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding4ByteEnd> for ::fidl_test_padding::Padding4ByteEnd {
#[inline]
fn compat_from(value: crate::Padding4ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding4ByteEnd> for crate::Padding4ByteEnd {
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding4ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding4ByteMiddle>
for ::fidl_test_padding::Padding4ByteMiddle
{
#[inline]
fn compat_from(value: crate::Padding4ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding4ByteMiddle>
for crate::Padding4ByteMiddle
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding4ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding5ByteEnd> for ::fidl_test_padding::Padding5ByteEnd {
#[inline]
fn compat_from(value: crate::Padding5ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding5ByteEnd> for crate::Padding5ByteEnd {
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding5ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding5ByteMiddle>
for ::fidl_test_padding::Padding5ByteMiddle
{
#[inline]
fn compat_from(value: crate::Padding5ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding5ByteMiddle>
for crate::Padding5ByteMiddle
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding5ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
c: ::fidl_next::CompatFrom::compat_from(value.c),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding6ByteEnd> for ::fidl_test_padding::Padding6ByteEnd {
#[inline]
fn compat_from(value: crate::Padding6ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding6ByteEnd> for crate::Padding6ByteEnd {
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding6ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding6ByteMiddle>
for ::fidl_test_padding::Padding6ByteMiddle
{
#[inline]
fn compat_from(value: crate::Padding6ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding6ByteMiddle>
for crate::Padding6ByteMiddle
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding6ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding7ByteEnd> for ::fidl_test_padding::Padding7ByteEnd {
#[inline]
fn compat_from(value: crate::Padding7ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding7ByteEnd> for crate::Padding7ByteEnd {
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding7ByteEnd) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<crate::Padding7ByteMiddle>
for ::fidl_test_padding::Padding7ByteMiddle
{
#[inline]
fn compat_from(value: crate::Padding7ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
impl ::fidl_next::CompatFrom<::fidl_test_padding::Padding7ByteMiddle>
for crate::Padding7ByteMiddle
{
#[inline]
fn compat_from(value: ::fidl_test_padding::Padding7ByteMiddle) -> Self {
Self {
a: ::fidl_next::CompatFrom::compat_from(value.a),
b: ::fidl_next::CompatFrom::compat_from(value.b),
}
}
}
}