tools/fidl/fidlgen_rust/goldens/driver_two_way.rs.golden

// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = output_index_json

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_test_drivertwoway__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[cfg(feature = "driver")]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct TwoWayMarker;

#[cfg(feature = "driver")]
impl fidl_driver::endpoints::DriverProtocolMarker for TwoWayMarker {
    const DEBUG_NAME: &'static str = "(anonymous) TwoWay";
}

#[cfg(feature = "driver")]
#[derive(Debug)]
pub enum TwoWayRequest {
    Add { addend1: u16, addend2: u16, responder: TwoWayAddResponder },
}

#[cfg(feature = "driver")]
impl TwoWayRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_add(self) -> Option<(u16, u16, TwoWayAddResponder)> {
        if let TwoWayRequest::Add { addend1, addend2, responder } = self {
            Some((addend1, addend2, responder))
        } else {
            None
        }
    }

    pub fn new_add(self, addend1: u16, addend2: u16, tx_id: u32) -> Self {
        Self::Add { addend1, addend2, responder: TwoWayAddResponder { tx_id } }
    }

    pub fn r#add_as_message(
        arena: fdf::Arena,
        mut addend1: u16,
        mut addend2: u16,
        tx_id: u32,
    ) -> Result<fdf::Message<[u8]>, fidl::Error> {
        let ordinal = 0xdbc3aab0bc6850f;
        let dynamic_flags = fidl::encoding::DynamicFlags::empty();
        let body = (addend1, addend2);
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
            body,
        };
        fidl::encoding::with_tls_encoded::<
            fidl::encoding::TransactionMessageType<TwoWayAddRequest>,
            fidl::encoding::DefaultFuchsiaResourceDialect,
            fdf::Message<[u8]>,
        >(msg, |bytes, mut handles| {
            let handles = arena.insert_from_iter(
                std::mem::take(handles)
                    .into_iter()
                    .map(fidl_driver::encoding::mixed_from_handle_disposition),
            );
            Ok(fdf::Message::new(&arena, Some(arena.insert_slice(bytes)), Some(handles)))
        })
    }

    #[allow(irrefutable_let_patterns)]
    pub fn read_from(bytes: &[u8], _handles: &mut [zx::HandleInfo]) -> Result<Self, fidl::Error> {
        let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

        match header.ordinal {
            0xdbc3aab0bc6850f => {
                header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                let mut req = fidl::new_empty!(
                    TwoWayAddRequest,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                );
                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<TwoWayAddRequest>(&header, _body_bytes, _handles, &mut req)?;
                Ok(TwoWayRequest::Add {
                    addend1: req.addend1,
                    addend2: req.addend2,

                    responder: TwoWayAddResponder { tx_id: header.tx_id },
                })
            }
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: header.ordinal,
                protocol_name:
                    <TwoWayMarker as fidl_driver::endpoints::DriverProtocolMarker>::DEBUG_NAME,
            }),
        }
    }

    pub fn read_from_message(
        mut message: fdf::Message<[u8]>,
    ) -> Result<(fdf::Arena, Self), fidl::Error> {
        let (arena, Some(body), Some(handles)) = message.take_arena_boxes() else {
            return Err(fidl::Error::Invalid);
        };
        let mut handles = arena.try_insert_from_iter(
            handles
                .into_iter()
                .map(|handle| unsafe { fidl_driver::encoding::mixed_into_handle_info(handle) }),
        );
        let res = match handles {
            Ok(ref mut handles) => Self::read_from(&*body, handles)?,
            Err(_) => return Err(fidl::Error::Invalid),
        };
        std::mem::drop((body, handles));
        Ok((message.take_arena(), res))
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            TwoWayRequest::Add { .. } => "add",
        }
    }
}

/// Like [`TwoWayRequest::read_from_message`] except it drops the [`Arena`].
#[cfg(feature = "driver")]
impl std::convert::TryFrom<fdf::Message<[u8]>> for TwoWayRequest {
    type Error = fidl::Error;
    fn try_from(msg: fdf::Message<[u8]>) -> Result<TwoWayRequest, fidl::Error> {
        Ok(TwoWayRequest::read_from_message(msg)?.1)
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct TwoWayAddResponder {
    tx_id: u32,
}

#[cfg(feature = "driver")]
impl TwoWayAddResponder {
    pub fn send_response(
        &self,
        server_handle: &fdf::Channel<[u8]>,
        mut sum: u16,
    ) -> Result<(), fidl::Error> {
        let msg = fidl::encoding::TransactionMessage {
            header: fidl::encoding::TransactionHeader::new(
                self.tx_id,
                0xdbc3aab0bc6850f,
                fidl::encoding::DynamicFlags::empty(),
            ),
            body: (sum,),
        };
        fidl::encoding::with_tls_encoded::<
            fidl::encoding::TransactionMessageType<TwoWayAddResponse>,
            fidl::encoding::DefaultFuchsiaResourceDialect,
            (),
        >(msg, |body, _handles| {
            server_handle
                .write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
                .unwrap();
            Ok(())
        })
    }
}

mod internal {
    use super::*;
}