Google Git
Sign in
fuchsia / fuchsia / refs/heads/main / . / tools / fidl / fidlgen_rust / goldens / unknown_interactions.rs.golden
blob: 3d3d040df23b3a0de4a1b40717783dbfb5f8570b [file] [log] [blame] [edit]
// 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_unknowninteractions__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;
#[cfg(feature = "driver")]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct UnknownInteractionsAjarDriverProtocolMarker;
#[cfg(feature = "driver")]
impl fidl_driver::endpoints::DriverProtocolMarker for UnknownInteractionsAjarDriverProtocolMarker {
const DEBUG_NAME: &'static str = "(anonymous) UnknownInteractionsAjarDriverProtocol";
}
pub type UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResult =
Result<UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResult =
Result<UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse, i32>;
#[cfg(feature = "driver")]
#[derive(Debug)]
pub enum UnknownInteractionsAjarDriverProtocolRequest {
StrictOneWay {},
FlexibleOneWay {},
StrictTwoWay {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayResponder,
},
StrictTwoWayFields {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponder,
},
StrictTwoWayUnion {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponder,
},
StrictTwoWayTable {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponder,
},
StrictTwoWayErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponder,
},
StrictTwoWayFieldsErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponder,
},
StrictTwoWayUnionErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponder,
},
StrictTwoWayTableErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponder,
},
/// An interaction was received which does not match any known method.
#[non_exhaustive]
_UnknownMethod {
/// Ordinal of the method that was called.
ordinal: u64,
},
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_one_way(self) -> Option<()> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictOneWay {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_one_way(self) -> Option<()> {
if let UnknownInteractionsAjarDriverProtocolRequest::FlexibleOneWay {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayFields { responder } = self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayUnion { responder } = self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayTable { responder } = self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_err(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayFieldsErr { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union_err(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayUnionErr { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table_err(
self,
) -> Option<(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponder)> {
if let UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayTableErr { responder } =
self
{
Some((responder))
} else {
None
}
}
pub fn new_strict_one_way(self) -> Self {
Self::StrictOneWay {}
}
pub fn new_flexible_one_way(self) -> Self {
Self::FlexibleOneWay {}
}
pub fn new_strict_two_way(self, tx_id: u32) -> Self {
Self::StrictTwoWay {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayResponder { tx_id },
}
}
pub fn new_strict_two_way_fields(self, tx_id: u32) -> Self {
Self::StrictTwoWayFields {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponder { tx_id },
}
}
pub fn new_strict_two_way_union(self, tx_id: u32) -> Self {
Self::StrictTwoWayUnion {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponder { tx_id },
}
}
pub fn new_strict_two_way_table(self, tx_id: u32) -> Self {
Self::StrictTwoWayTable {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponder { tx_id },
}
}
pub fn new_strict_two_way_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponder { tx_id },
}
}
pub fn new_strict_two_way_fields_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayFieldsErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id,
},
}
}
pub fn new_strict_two_way_union_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayUnionErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponder { tx_id },
}
}
pub fn new_strict_two_way_table_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayTableErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponder { tx_id },
}
}
pub fn r#strict_one_way_as_message(
arena: fdf::Arena,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let tx_id = 0;
let ordinal = 0x2c98c07246851dd;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_one_way_as_message(
arena: fdf::Arena,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let tx_id = 0;
let ordinal = 0x349c2bccad7bb7de;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x7425718300ee74d;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_fields_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0xc851a0402fa4b84;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_union_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x7c3cfc6995dc5409;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_table_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x2b3761549bfc3e9d;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x61f06cf6be8289b5;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_fields_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x5a12fee3285d4aff;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_union_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x20306f4020a7cd83;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_table_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x5f85b4b7b9f47b39;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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 {
0x2c98c07246851dd => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictOneWay {
})
}
0x349c2bccad7bb7de => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::FlexibleOneWay {
})
}
0x7425718300ee74d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWay {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayResponder {
tx_id: header.tx_id,
},
})
}
0xc851a0402fa4b84 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayFields {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponder {
tx_id: header.tx_id,
},
})
}
0x7c3cfc6995dc5409 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayUnion {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponder {
tx_id: header.tx_id,
},
})
}
0x2b3761549bfc3e9d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayTable {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponder {
tx_id: header.tx_id,
},
})
}
0x61f06cf6be8289b5 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponder {
tx_id: header.tx_id,
},
})
}
0x5a12fee3285d4aff => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayFieldsErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id: header.tx_id,
},
})
}
0x20306f4020a7cd83 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayUnionErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponder {
tx_id: header.tx_id,
},
})
}
0x5f85b4b7b9f47b39 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayTableErr {
responder: UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponder {
tx_id: header.tx_id,
},
})
}
_ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(UnknownInteractionsAjarDriverProtocolRequest::_UnknownMethod {
ordinal: header.ordinal,
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <UnknownInteractionsAjarDriverProtocolMarker 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 {
UnknownInteractionsAjarDriverProtocolRequest::StrictOneWay { .. } => "strict_one_way",
UnknownInteractionsAjarDriverProtocolRequest::FlexibleOneWay { .. } => {
"flexible_one_way"
}
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWay { .. } => "strict_two_way",
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayFields { .. } => {
"strict_two_way_fields"
}
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayUnion { .. } => {
"strict_two_way_union"
}
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayTable { .. } => {
"strict_two_way_table"
}
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayErr { .. } => {
"strict_two_way_err"
}
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayFieldsErr { .. } => {
"strict_two_way_fields_err"
}
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayUnionErr { .. } => {
"strict_two_way_union_err"
}
UnknownInteractionsAjarDriverProtocolRequest::StrictTwoWayTableErr { .. } => {
"strict_two_way_table_err"
}
UnknownInteractionsAjarDriverProtocolRequest::_UnknownMethod { .. } => {
"unknown one-way method"
}
}
}
}
/// Like [`UnknownInteractionsAjarDriverProtocolRequest::read_from_message`] except it drops the [`Arena`].
#[cfg(feature = "driver")]
impl std::convert::TryFrom<fdf::Message<[u8]>> for UnknownInteractionsAjarDriverProtocolRequest {
type Error = fidl::Error;
fn try_from(
msg: fdf::Message<[u8]>,
) -> Result<UnknownInteractionsAjarDriverProtocolRequest, fidl::Error> {
Ok(UnknownInteractionsAjarDriverProtocolRequest::read_from_message(msg)?.1)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayResponder {
pub fn send_response(&self, server_handle: &fdf::Channel<[u8]>) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x7425718300ee74d,
fidl::encoding::DynamicFlags::empty(),
),
body: (),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut some_field: i32,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0xc851a0402fa4b84,
fidl::encoding::DynamicFlags::empty(),
),
body: (some_field,),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x7c3cfc6995dc5409,
fidl::encoding::DynamicFlags::empty(),
),
body: payload,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x2b3761549bfc3e9d,
fidl::encoding::DynamicFlags::empty(),
),
body: payload,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<(), i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x61f06cf6be8289b5,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<i32, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x5a12fee3285d4aff,
fidl::encoding::DynamicFlags::empty(),
),
body: result.map(|some_field| (some_field,)),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<&UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x20306f4020a7cd83,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<&UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x5f85b4b7b9f47b39,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsAjarDriverProtocolStrictTwoWayTableErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct UnknownInteractionsAjarProtocolMarker;
impl fidl::endpoints::ProtocolMarker for UnknownInteractionsAjarProtocolMarker {
type Proxy = UnknownInteractionsAjarProtocolProxy;
type RequestStream = UnknownInteractionsAjarProtocolRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = UnknownInteractionsAjarProtocolSynchronousProxy;
const DEBUG_NAME: &'static str = "(anonymous) UnknownInteractionsAjarProtocol";
}
pub type UnknownInteractionsAjarProtocolStrictTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult =
Result<UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult =
Result<UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse, i32>;
pub trait UnknownInteractionsAjarProtocolProxyInterface: Send + Sync {
fn r#strict_one_way(&self) -> Result<(), fidl::Error>;
fn r#flexible_one_way(&self) -> Result<(), fidl::Error>;
type StrictTwoWayResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#strict_two_way(&self) -> Self::StrictTwoWayResponseFut;
type StrictTwoWayFieldsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
+ Send;
fn r#strict_two_way_fields(&self) -> Self::StrictTwoWayFieldsResponseFut;
type StrictTwoWayUnionResponseFut: std::future::Future<
Output = Result<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, fidl::Error>,
> + Send;
fn r#strict_two_way_union(&self) -> Self::StrictTwoWayUnionResponseFut;
type StrictTwoWayTableResponseFut: std::future::Future<
Output = Result<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse, fidl::Error>,
> + Send;
fn r#strict_two_way_table(&self) -> Self::StrictTwoWayTableResponseFut;
type StrictTwoWayErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsAjarProtocolStrictTwoWayErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_err(&self) -> Self::StrictTwoWayErrResponseFut;
type StrictTwoWayFieldsErrResponseFut: std::future::Future<
Output = Result<
UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult,
fidl::Error,
>,
> + Send;
fn r#strict_two_way_fields_err(&self) -> Self::StrictTwoWayFieldsErrResponseFut;
type StrictTwoWayUnionErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_union_err(&self) -> Self::StrictTwoWayUnionErrResponseFut;
type StrictTwoWayTableErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_table_err(&self) -> Self::StrictTwoWayTableErrResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UnknownInteractionsAjarProtocolSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UnknownInteractionsAjarProtocolSynchronousProxy {
type Proxy = UnknownInteractionsAjarProtocolProxy;
type Protocol = UnknownInteractionsAjarProtocolMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl UnknownInteractionsAjarProtocolSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<UnknownInteractionsAjarProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
/// Waits until an event arrives and returns it. It is safe for other
/// threads to make concurrent requests while waiting for an event.
pub fn wait_for_event(
&self,
deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsAjarProtocolEvent, fidl::Error> {
UnknownInteractionsAjarProtocolEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0xd4663d6b2b5048b,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x2275b8171ae4834f,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#strict_two_way(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x50e66d328336038,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_fields(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<i32, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
>(
(),
0x1947e36d61e4493a,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.some_field)
}
pub fn r#strict_two_way_union(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
>(
(),
0x5177371967e0e6d1,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_table(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
>(
(),
0x6f8f9343b34e2ed4,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayErrResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(),
0x5b47637577c69006,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#strict_two_way_fields_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
i32,
>>(
(), 0x844ff7bb3f186d9, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x.some_field))
}
pub fn r#strict_two_way_union_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse,
i32,
>>(
(), 0x2cbfd5a859d4ac95, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x))
}
pub fn r#strict_two_way_table_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse,
i32,
>>(
(), 0x30c9e1b3da57dc37, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x))
}
}
#[cfg(target_os = "fuchsia")]
impl From<UnknownInteractionsAjarProtocolSynchronousProxy> for zx::Handle {
fn from(value: UnknownInteractionsAjarProtocolSynchronousProxy) -> Self {
value.into_channel().into()
}
}
#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for UnknownInteractionsAjarProtocolSynchronousProxy {
fn from(value: fidl::Channel) -> Self {
Self::new(value)
}
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for UnknownInteractionsAjarProtocolSynchronousProxy {
type Protocol = UnknownInteractionsAjarProtocolMarker;
fn from_client(
value: fidl::endpoints::ClientEnd<UnknownInteractionsAjarProtocolMarker>,
) -> Self {
Self::new(value.into_channel())
}
}
#[derive(Debug, Clone)]
pub struct UnknownInteractionsAjarProtocolProxy {
client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}
impl fidl::endpoints::Proxy for UnknownInteractionsAjarProtocolProxy {
type Protocol = UnknownInteractionsAjarProtocolMarker;
fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl UnknownInteractionsAjarProtocolProxy {
/// Create a new Proxy for test.unknowninteractions/UnknownInteractionsAjarProtocol.
pub fn new(channel: ::fidl::AsyncChannel) -> Self {
let protocol_name =
<UnknownInteractionsAjarProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
/// Get a Stream of events from the remote end of the protocol.
///
/// # Panics
///
/// Panics if the event stream was already taken.
pub fn take_event_stream(&self) -> UnknownInteractionsAjarProtocolEventStream {
UnknownInteractionsAjarProtocolEventStream {
event_receiver: self.client.take_event_receiver(),
}
}
pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_one_way(self)
}
pub fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
UnknownInteractionsAjarProtocolProxyInterface::r#flexible_one_way(self)
}
pub fn r#strict_two_way(
&self,
) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way(self)
}
pub fn r#strict_two_way_fields(
&self,
) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way_fields(self)
}
pub fn r#strict_two_way_union(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way_union(self)
}
pub fn r#strict_two_way_table(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way_table(self)
}
pub fn r#strict_two_way_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way_err(self)
}
pub fn r#strict_two_way_fields_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way_fields_err(self)
}
pub fn r#strict_two_way_union_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way_union_err(self)
}
pub fn r#strict_two_way_table_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsAjarProtocolProxyInterface::r#strict_two_way_table_err(self)
}
}
impl UnknownInteractionsAjarProtocolProxyInterface for UnknownInteractionsAjarProtocolProxy {
fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0xd4663d6b2b5048b,
fidl::encoding::DynamicFlags::empty(),
)
}
fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x2275b8171ae4834f,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
type StrictTwoWayResponseFut =
fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#strict_two_way(&self) -> Self::StrictTwoWayResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x50e66d328336038,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x50e66d328336038,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayFieldsResponseFut =
fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#strict_two_way_fields(&self) -> Self::StrictTwoWayFieldsResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x1947e36d61e4493a,
>(_buf?)?;
Ok(_response.some_field)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
(),
0x1947e36d61e4493a,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayUnionResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_union(&self) -> Self::StrictTwoWayUnionResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x5177371967e0e6d1,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
>(
(),
0x5177371967e0e6d1,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayTableResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_table(&self) -> Self::StrictTwoWayTableResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x6f8f9343b34e2ed4,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
>(
(),
0x6f8f9343b34e2ed4,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_err(&self) -> Self::StrictTwoWayErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x5b47637577c69006,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayErrResult,
>(
(),
0x5b47637577c69006,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_fields_err(&self) -> Self::StrictTwoWayFieldsErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x844ff7bb3f186d9,
>(_buf?)?;
Ok(_response.map(|x| x.some_field))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResult,
>(
(),
0x844ff7bb3f186d9,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayUnionErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_union_err(&self) -> Self::StrictTwoWayUnionErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x2cbfd5a859d4ac95,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResult,
>(
(),
0x2cbfd5a859d4ac95,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayTableErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_table_err(&self) -> Self::StrictTwoWayTableErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x30c9e1b3da57dc37,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsAjarProtocolStrictTwoWayTableErrResult,
>(
(),
0x30c9e1b3da57dc37,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct UnknownInteractionsAjarProtocolEventStream {
event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}
impl std::marker::Unpin for UnknownInteractionsAjarProtocolEventStream {}
impl futures::stream::FusedStream for UnknownInteractionsAjarProtocolEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for UnknownInteractionsAjarProtocolEventStream {
type Item = Result<UnknownInteractionsAjarProtocolEvent, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
&mut self.event_receiver,
cx
)?) {
Some(buf) => {
std::task::Poll::Ready(Some(UnknownInteractionsAjarProtocolEvent::decode(buf)))
}
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum UnknownInteractionsAjarProtocolEvent {
StrictEvent {},
StrictEventFields {
some_field: i32,
},
StrictEventUnion {
payload: UnknownInteractionsAjarProtocolStrictEventUnionRequest,
},
StrictEventTable {
payload: UnknownInteractionsAjarProtocolStrictEventTableRequest,
},
FlexibleEvent {},
FlexibleEventFields {
some_field: i32,
},
FlexibleEventUnion {
payload: UnknownInteractionsAjarProtocolFlexibleEventUnionRequest,
},
FlexibleEventTable {
payload: UnknownInteractionsAjarProtocolFlexibleEventTableRequest,
},
#[non_exhaustive]
_UnknownEvent {
/// Ordinal of the event that was sent.
ordinal: u64,
},
}
impl UnknownInteractionsAjarProtocolEvent {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event(self) -> Option<()> {
if let UnknownInteractionsAjarProtocolEvent::StrictEvent {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_fields(self) -> Option<i32> {
if let UnknownInteractionsAjarProtocolEvent::StrictEventFields { some_field } = self {
Some((some_field))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_union(
self,
) -> Option<UnknownInteractionsAjarProtocolStrictEventUnionRequest> {
if let UnknownInteractionsAjarProtocolEvent::StrictEventUnion { payload } = self {
Some((payload))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_table(
self,
) -> Option<UnknownInteractionsAjarProtocolStrictEventTableRequest> {
if let UnknownInteractionsAjarProtocolEvent::StrictEventTable { payload } = self {
Some((payload))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event(self) -> Option<()> {
if let UnknownInteractionsAjarProtocolEvent::FlexibleEvent {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event_fields(self) -> Option<i32> {
if let UnknownInteractionsAjarProtocolEvent::FlexibleEventFields { some_field } = self {
Some((some_field))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event_union(
self,
) -> Option<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> {
if let UnknownInteractionsAjarProtocolEvent::FlexibleEventUnion { payload } = self {
Some((payload))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event_table(
self,
) -> Option<UnknownInteractionsAjarProtocolFlexibleEventTableRequest> {
if let UnknownInteractionsAjarProtocolEvent::FlexibleEventTable { payload } = self {
Some((payload))
} else {
None
}
}
/// Decodes a message buffer as a [`UnknownInteractionsAjarProtocolEvent`].
fn decode(
mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
) -> Result<UnknownInteractionsAjarProtocolEvent, fidl::Error> {
let (bytes, _handles) = buf.split_mut();
let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
debug_assert_eq!(tx_header.tx_id, 0);
match tx_header.ordinal {
0x6022ae999e9dc2b0 => {
let mut out = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::StrictEvent {
}
))
}
0x510586752445c769 => {
let mut out = fidl::new_empty!(UnknownInteractionsAjarProtocolStrictEventFieldsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsAjarProtocolStrictEventFieldsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::StrictEventFields {some_field: out.some_field,
}
))
}
0x57794b4cc91f816f => {
let mut out = fidl::new_empty!(UnknownInteractionsAjarProtocolStrictEventUnionRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsAjarProtocolStrictEventUnionRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::StrictEventUnion {payload: out,
}
))
}
0x92639249201f89d => {
let mut out = fidl::new_empty!(UnknownInteractionsAjarProtocolStrictEventTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsAjarProtocolStrictEventTableRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::StrictEventTable {payload: out,
}
))
}
0x11c9ba570ce71df3 => {
let mut out = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::FlexibleEvent {
}
))
}
0x3ba8fd32bf87d862 => {
let mut out = fidl::new_empty!(UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::FlexibleEventFields {some_field: out.some_field,
}
))
}
0x7c3823f47ce0fcad => {
let mut out = fidl::new_empty!(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::FlexibleEventUnion {payload: out,
}
))
}
0x9ca944d1d6436b0 => {
let mut out = fidl::new_empty!(UnknownInteractionsAjarProtocolFlexibleEventTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsAjarProtocolFlexibleEventTableRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsAjarProtocolEvent::FlexibleEventTable {payload: out,
}
))
}
_ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(UnknownInteractionsAjarProtocolEvent::_UnknownEvent {
ordinal: tx_header.ordinal,
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name: <UnknownInteractionsAjarProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
})
}
}
}
/// A Stream of incoming requests for test.unknowninteractions/UnknownInteractionsAjarProtocol.
pub struct UnknownInteractionsAjarProtocolRequestStream {
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
is_terminated: bool,
}
impl std::marker::Unpin for UnknownInteractionsAjarProtocolRequestStream {}
impl futures::stream::FusedStream for UnknownInteractionsAjarProtocolRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for UnknownInteractionsAjarProtocolRequestStream {
type Protocol = UnknownInteractionsAjarProtocolMarker;
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
}
fn control_handle(&self) -> Self::ControlHandle {
UnknownInteractionsAjarProtocolControlHandle { inner: self.inner.clone() }
}
fn into_inner(
self,
) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
{
(self.inner, self.is_terminated)
}
fn from_inner(
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
is_terminated: bool,
) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for UnknownInteractionsAjarProtocolRequestStream {
type Item = Result<UnknownInteractionsAjarProtocolRequest, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
let this = &mut *self;
if this.inner.check_shutdown(cx) {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
if this.is_terminated {
panic!("polled UnknownInteractionsAjarProtocolRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
|bytes, handles| {
match this.inner.channel().read_etc(cx, bytes, handles) {
std::task::Poll::Ready(Ok(())) => {}
std::task::Poll::Pending => return std::task::Poll::Pending,
std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
e.into(),
))));
}
}
// A message has been received from the channel
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0xd4663d6b2b5048b => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictOneWay {
control_handle,
})
}
0x2275b8171ae4834f => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::FlexibleOneWay {
control_handle,
})
}
0x50e66d328336038 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWay {
responder: UnknownInteractionsAjarProtocolStrictTwoWayResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1947e36d61e4493a => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWayFields {
responder: UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x5177371967e0e6d1 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWayUnion {
responder: UnknownInteractionsAjarProtocolStrictTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6f8f9343b34e2ed4 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWayTable {
responder: UnknownInteractionsAjarProtocolStrictTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x5b47637577c69006 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWayErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x844ff7bb3f186d9 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWayFieldsErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2cbfd5a859d4ac95 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWayUnionErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x30c9e1b3da57dc37 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsAjarProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsAjarProtocolRequest::StrictTwoWayTableErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(UnknownInteractionsAjarProtocolRequest::_UnknownMethod {
ordinal: header.ordinal,
control_handle: UnknownInteractionsAjarProtocolControlHandle { inner: this.inner.clone() },
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <UnknownInteractionsAjarProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
},
)
}
}
#[derive(Debug)]
pub enum UnknownInteractionsAjarProtocolRequest {
StrictOneWay {
control_handle: UnknownInteractionsAjarProtocolControlHandle,
},
FlexibleOneWay {
control_handle: UnknownInteractionsAjarProtocolControlHandle,
},
StrictTwoWay {
responder: UnknownInteractionsAjarProtocolStrictTwoWayResponder,
},
StrictTwoWayFields {
responder: UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponder,
},
StrictTwoWayUnion {
responder: UnknownInteractionsAjarProtocolStrictTwoWayUnionResponder,
},
StrictTwoWayTable {
responder: UnknownInteractionsAjarProtocolStrictTwoWayTableResponder,
},
StrictTwoWayErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayErrResponder,
},
StrictTwoWayFieldsErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponder,
},
StrictTwoWayUnionErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponder,
},
StrictTwoWayTableErr {
responder: UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponder,
},
/// An interaction was received which does not match any known method.
#[non_exhaustive]
_UnknownMethod {
/// Ordinal of the method that was called.
ordinal: u64,
control_handle: UnknownInteractionsAjarProtocolControlHandle,
},
}
impl UnknownInteractionsAjarProtocolRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_one_way(self) -> Option<(UnknownInteractionsAjarProtocolControlHandle)> {
if let UnknownInteractionsAjarProtocolRequest::StrictOneWay { control_handle } = self {
Some((control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_one_way(self) -> Option<(UnknownInteractionsAjarProtocolControlHandle)> {
if let UnknownInteractionsAjarProtocolRequest::FlexibleOneWay { control_handle } = self {
Some((control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWayFields { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWayUnion { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayTableResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWayTable { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_err(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayErrResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWayErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWayFieldsErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union_err(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWayUnionErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table_err(
self,
) -> Option<(UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponder)> {
if let UnknownInteractionsAjarProtocolRequest::StrictTwoWayTableErr { responder } = self {
Some((responder))
} else {
None
}
}
/// Name of the method defined in FIDL
pub fn method_name(&self) -> &'static str {
match *self {
UnknownInteractionsAjarProtocolRequest::StrictOneWay { .. } => "strict_one_way",
UnknownInteractionsAjarProtocolRequest::FlexibleOneWay { .. } => "flexible_one_way",
UnknownInteractionsAjarProtocolRequest::StrictTwoWay { .. } => "strict_two_way",
UnknownInteractionsAjarProtocolRequest::StrictTwoWayFields { .. } => {
"strict_two_way_fields"
}
UnknownInteractionsAjarProtocolRequest::StrictTwoWayUnion { .. } => {
"strict_two_way_union"
}
UnknownInteractionsAjarProtocolRequest::StrictTwoWayTable { .. } => {
"strict_two_way_table"
}
UnknownInteractionsAjarProtocolRequest::StrictTwoWayErr { .. } => "strict_two_way_err",
UnknownInteractionsAjarProtocolRequest::StrictTwoWayFieldsErr { .. } => {
"strict_two_way_fields_err"
}
UnknownInteractionsAjarProtocolRequest::StrictTwoWayUnionErr { .. } => {
"strict_two_way_union_err"
}
UnknownInteractionsAjarProtocolRequest::StrictTwoWayTableErr { .. } => {
"strict_two_way_table_err"
}
UnknownInteractionsAjarProtocolRequest::_UnknownMethod { .. } => {
"unknown one-way method"
}
}
}
}
#[derive(Debug, Clone)]
pub struct UnknownInteractionsAjarProtocolControlHandle {
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}
impl fidl::endpoints::ControlHandle for UnknownInteractionsAjarProtocolControlHandle {
fn shutdown(&self) {
self.inner.shutdown()
}
fn shutdown_with_epitaph(&self, status: zx_status::Status) {
self.inner.shutdown_with_epitaph(status)
}
fn is_closed(&self) -> bool {
self.inner.channel().is_closed()
}
fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
#[cfg(target_os = "fuchsia")]
fn signal_peer(
&self,
clear_mask: zx::Signals,
set_mask: zx::Signals,
) -> Result<(), zx_status::Status> {
use fidl::Peered;
self.inner.channel().signal_peer(clear_mask, set_mask)
}
}
impl UnknownInteractionsAjarProtocolControlHandle {
pub fn send_strict_event(&self) -> Result<(), fidl::Error> {
self.inner.send::<fidl::encoding::EmptyPayload>(
(),
0,
0x6022ae999e9dc2b0,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_fields(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsAjarProtocolStrictEventFieldsRequest>(
(some_field,),
0,
0x510586752445c769,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_union(
&self,
mut payload: &UnknownInteractionsAjarProtocolStrictEventUnionRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsAjarProtocolStrictEventUnionRequest>(
payload,
0,
0x57794b4cc91f816f,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_table(
&self,
mut payload: &UnknownInteractionsAjarProtocolStrictEventTableRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsAjarProtocolStrictEventTableRequest>(
payload,
0,
0x92639249201f89d,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_flexible_event(&self) -> Result<(), fidl::Error> {
self.inner.send::<fidl::encoding::EmptyPayload>(
(),
0,
0x11c9ba570ce71df3,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn send_flexible_event_fields(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>(
(some_field,),
0,
0x3ba8fd32bf87d862,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn send_flexible_event_union(
&self,
mut payload: &UnknownInteractionsAjarProtocolFlexibleEventUnionRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>(
payload,
0,
0x7c3823f47ce0fcad,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn send_flexible_event_table(
&self,
mut payload: &UnknownInteractionsAjarProtocolFlexibleEventTableRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsAjarProtocolFlexibleEventTableRequest>(
payload,
0,
0x9ca944d1d6436b0,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x50e66d328336038,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>(
(some_field,),
self.tx_id,
0x1947e36d61e4493a,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayUnionResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayUnionResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>(
payload,
self.tx_id,
0x5177371967e0e6d1,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayTableResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayTableResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayTableResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsAjarProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>(
payload,
self.tx_id,
0x6f8f9343b34e2ed4,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayErrResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
result,
self.tx_id,
0x5b47637577c69006,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayFieldsErrResponse,
i32,
>>(
result.map(|some_field| (some_field,)),
self.tx_id,
0x844ff7bb3f186d9,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayUnionErrResponse,
i32,
>>(
result,
self.tx_id,
0x2cbfd5a859d4ac95,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsAjarProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsAjarProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponder {
type ControlHandle = UnknownInteractionsAjarProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsAjarProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsAjarProtocolStrictTwoWayTableErrResponse,
i32,
>>(
result,
self.tx_id,
0x30c9e1b3da57dc37,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[cfg(feature = "driver")]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct UnknownInteractionsClosedDriverProtocolMarker;
#[cfg(feature = "driver")]
impl fidl_driver::endpoints::DriverProtocolMarker
for UnknownInteractionsClosedDriverProtocolMarker
{
const DEBUG_NAME: &'static str = "(anonymous) UnknownInteractionsClosedDriverProtocol";
}
pub type UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResult =
Result<UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResult =
Result<UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse, i32>;
#[cfg(feature = "driver")]
#[derive(Debug)]
pub enum UnknownInteractionsClosedDriverProtocolRequest {
StrictOneWay {},
StrictTwoWay {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayResponder,
},
StrictTwoWayFields {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponder,
},
StrictTwoWayUnion {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponder,
},
StrictTwoWayTable {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponder,
},
StrictTwoWayErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponder,
},
StrictTwoWayFieldsErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponder,
},
StrictTwoWayUnionErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponder,
},
StrictTwoWayTableErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponder,
},
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_one_way(self) -> Option<()> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictOneWay {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayFields { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayUnion { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayTable { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_err(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayErr { responder } = self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayFieldsErr { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union_err(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayUnionErr { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table_err(
self,
) -> Option<(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponder)> {
if let UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayTableErr { responder } =
self
{
Some((responder))
} else {
None
}
}
pub fn new_strict_one_way(self) -> Self {
Self::StrictOneWay {}
}
pub fn new_strict_two_way(self, tx_id: u32) -> Self {
Self::StrictTwoWay {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayResponder { tx_id },
}
}
pub fn new_strict_two_way_fields(self, tx_id: u32) -> Self {
Self::StrictTwoWayFields {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponder { tx_id },
}
}
pub fn new_strict_two_way_union(self, tx_id: u32) -> Self {
Self::StrictTwoWayUnion {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponder { tx_id },
}
}
pub fn new_strict_two_way_table(self, tx_id: u32) -> Self {
Self::StrictTwoWayTable {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponder { tx_id },
}
}
pub fn new_strict_two_way_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponder { tx_id },
}
}
pub fn new_strict_two_way_fields_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayFieldsErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id,
},
}
}
pub fn new_strict_two_way_union_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayUnionErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponder {
tx_id,
},
}
}
pub fn new_strict_two_way_table_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayTableErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponder {
tx_id,
},
}
}
pub fn r#strict_one_way_as_message(
arena: fdf::Arena,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let tx_id = 0;
let ordinal = 0x7e73c20dcb0f8182;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x271357bcfbec7203;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_fields_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x4ff44f0dbaab1b86;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_union_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x646921d63346317c;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_table_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x19873317e6b13f7f;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x3c614a3f9bf14ca1;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_fields_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x36953d7cfe797456;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_union_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x3fd2c0b0083e518d;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_table_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x1437ccf963f1db5d;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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 {
0x7e73c20dcb0f8182 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictOneWay {
})
}
0x271357bcfbec7203 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWay {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayResponder {
tx_id: header.tx_id,
},
})
}
0x4ff44f0dbaab1b86 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayFields {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponder {
tx_id: header.tx_id,
},
})
}
0x646921d63346317c => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayUnion {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponder {
tx_id: header.tx_id,
},
})
}
0x19873317e6b13f7f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayTable {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponder {
tx_id: header.tx_id,
},
})
}
0x3c614a3f9bf14ca1 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponder {
tx_id: header.tx_id,
},
})
}
0x36953d7cfe797456 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayFieldsErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id: header.tx_id,
},
})
}
0x3fd2c0b0083e518d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayUnionErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponder {
tx_id: header.tx_id,
},
})
}
0x1437ccf963f1db5d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayTableErr {
responder: UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponder {
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <UnknownInteractionsClosedDriverProtocolMarker 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 {
UnknownInteractionsClosedDriverProtocolRequest::StrictOneWay { .. } => "strict_one_way",
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWay { .. } => "strict_two_way",
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayFields { .. } => {
"strict_two_way_fields"
}
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayUnion { .. } => {
"strict_two_way_union"
}
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayTable { .. } => {
"strict_two_way_table"
}
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayErr { .. } => {
"strict_two_way_err"
}
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayFieldsErr { .. } => {
"strict_two_way_fields_err"
}
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayUnionErr { .. } => {
"strict_two_way_union_err"
}
UnknownInteractionsClosedDriverProtocolRequest::StrictTwoWayTableErr { .. } => {
"strict_two_way_table_err"
}
}
}
}
/// Like [`UnknownInteractionsClosedDriverProtocolRequest::read_from_message`] except it drops the [`Arena`].
#[cfg(feature = "driver")]
impl std::convert::TryFrom<fdf::Message<[u8]>> for UnknownInteractionsClosedDriverProtocolRequest {
type Error = fidl::Error;
fn try_from(
msg: fdf::Message<[u8]>,
) -> Result<UnknownInteractionsClosedDriverProtocolRequest, fidl::Error> {
Ok(UnknownInteractionsClosedDriverProtocolRequest::read_from_message(msg)?.1)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayResponder {
pub fn send_response(&self, server_handle: &fdf::Channel<[u8]>) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x271357bcfbec7203,
fidl::encoding::DynamicFlags::empty(),
),
body: (),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut some_field: i32,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x4ff44f0dbaab1b86,
fidl::encoding::DynamicFlags::empty(),
),
body: (some_field,),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x646921d63346317c,
fidl::encoding::DynamicFlags::empty(),
),
body: payload,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x19873317e6b13f7f,
fidl::encoding::DynamicFlags::empty(),
),
body: payload,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<(), i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x3c614a3f9bf14ca1,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<i32, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x36953d7cfe797456,
fidl::encoding::DynamicFlags::empty(),
),
body: result.map(|some_field| (some_field,)),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<
&UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse,
i32,
>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x3fd2c0b0083e518d,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<
&UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse,
i32,
>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x1437ccf963f1db5d,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsClosedDriverProtocolStrictTwoWayTableErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct UnknownInteractionsClosedProtocolMarker;
impl fidl::endpoints::ProtocolMarker for UnknownInteractionsClosedProtocolMarker {
type Proxy = UnknownInteractionsClosedProtocolProxy;
type RequestStream = UnknownInteractionsClosedProtocolRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = UnknownInteractionsClosedProtocolSynchronousProxy;
const DEBUG_NAME: &'static str = "(anonymous) UnknownInteractionsClosedProtocol";
}
pub type UnknownInteractionsClosedProtocolStrictTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult =
Result<UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult =
Result<UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse, i32>;
pub trait UnknownInteractionsClosedProtocolProxyInterface: Send + Sync {
fn r#strict_one_way(&self) -> Result<(), fidl::Error>;
type StrictTwoWayResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#strict_two_way(&self) -> Self::StrictTwoWayResponseFut;
type StrictTwoWayFieldsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
+ Send;
fn r#strict_two_way_fields(&self) -> Self::StrictTwoWayFieldsResponseFut;
type StrictTwoWayUnionResponseFut: std::future::Future<
Output = Result<
UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
fidl::Error,
>,
> + Send;
fn r#strict_two_way_union(&self) -> Self::StrictTwoWayUnionResponseFut;
type StrictTwoWayTableResponseFut: std::future::Future<
Output = Result<
UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
fidl::Error,
>,
> + Send;
fn r#strict_two_way_table(&self) -> Self::StrictTwoWayTableResponseFut;
type StrictTwoWayErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsClosedProtocolStrictTwoWayErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_err(&self) -> Self::StrictTwoWayErrResponseFut;
type StrictTwoWayFieldsErrResponseFut: std::future::Future<
Output = Result<
UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult,
fidl::Error,
>,
> + Send;
fn r#strict_two_way_fields_err(&self) -> Self::StrictTwoWayFieldsErrResponseFut;
type StrictTwoWayUnionErrResponseFut: std::future::Future<
Output = Result<
UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult,
fidl::Error,
>,
> + Send;
fn r#strict_two_way_union_err(&self) -> Self::StrictTwoWayUnionErrResponseFut;
type StrictTwoWayTableErrResponseFut: std::future::Future<
Output = Result<
UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult,
fidl::Error,
>,
> + Send;
fn r#strict_two_way_table_err(&self) -> Self::StrictTwoWayTableErrResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UnknownInteractionsClosedProtocolSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UnknownInteractionsClosedProtocolSynchronousProxy {
type Proxy = UnknownInteractionsClosedProtocolProxy;
type Protocol = UnknownInteractionsClosedProtocolMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl UnknownInteractionsClosedProtocolSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name = <UnknownInteractionsClosedProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
/// Waits until an event arrives and returns it. It is safe for other
/// threads to make concurrent requests while waiting for an event.
pub fn wait_for_event(
&self,
deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsClosedProtocolEvent, fidl::Error> {
UnknownInteractionsClosedProtocolEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x59282385962da24,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#strict_two_way(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x5eda305d6b22f1f7,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_fields(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<i32, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
>(
(),
0x1323afa3e0541253,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.some_field)
}
pub fn r#strict_two_way_union(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
>(
(),
0x68b32554eb0f6fa7,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_table(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayTableResponse, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
>(
(),
0x6e4a94d44b69e785,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayErrResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(),
0x4fa35d5433db4d3a,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#strict_two_way_fields_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
i32,
>>(
(), 0xb22aebf23bb58fd, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x.some_field))
}
pub fn r#strict_two_way_union_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse,
i32,
>>(
(), 0xcd65d4d29a43c80, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x))
}
pub fn r#strict_two_way_table_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse,
i32,
>>(
(), 0x117dde20b92f7b90, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x))
}
}
#[cfg(target_os = "fuchsia")]
impl From<UnknownInteractionsClosedProtocolSynchronousProxy> for zx::Handle {
fn from(value: UnknownInteractionsClosedProtocolSynchronousProxy) -> Self {
value.into_channel().into()
}
}
#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for UnknownInteractionsClosedProtocolSynchronousProxy {
fn from(value: fidl::Channel) -> Self {
Self::new(value)
}
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for UnknownInteractionsClosedProtocolSynchronousProxy {
type Protocol = UnknownInteractionsClosedProtocolMarker;
fn from_client(
value: fidl::endpoints::ClientEnd<UnknownInteractionsClosedProtocolMarker>,
) -> Self {
Self::new(value.into_channel())
}
}
#[derive(Debug, Clone)]
pub struct UnknownInteractionsClosedProtocolProxy {
client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}
impl fidl::endpoints::Proxy for UnknownInteractionsClosedProtocolProxy {
type Protocol = UnknownInteractionsClosedProtocolMarker;
fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl UnknownInteractionsClosedProtocolProxy {
/// Create a new Proxy for test.unknowninteractions/UnknownInteractionsClosedProtocol.
pub fn new(channel: ::fidl::AsyncChannel) -> Self {
let protocol_name = <UnknownInteractionsClosedProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
/// Get a Stream of events from the remote end of the protocol.
///
/// # Panics
///
/// Panics if the event stream was already taken.
pub fn take_event_stream(&self) -> UnknownInteractionsClosedProtocolEventStream {
UnknownInteractionsClosedProtocolEventStream {
event_receiver: self.client.take_event_receiver(),
}
}
pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_one_way(self)
}
pub fn r#strict_two_way(
&self,
) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way(self)
}
pub fn r#strict_two_way_fields(
&self,
) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way_fields(self)
}
pub fn r#strict_two_way_union(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way_union(self)
}
pub fn r#strict_two_way_table(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way_table(self)
}
pub fn r#strict_two_way_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way_err(self)
}
pub fn r#strict_two_way_fields_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way_fields_err(self)
}
pub fn r#strict_two_way_union_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way_union_err(self)
}
pub fn r#strict_two_way_table_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsClosedProtocolProxyInterface::r#strict_two_way_table_err(self)
}
}
impl UnknownInteractionsClosedProtocolProxyInterface for UnknownInteractionsClosedProtocolProxy {
fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x59282385962da24,
fidl::encoding::DynamicFlags::empty(),
)
}
type StrictTwoWayResponseFut =
fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#strict_two_way(&self) -> Self::StrictTwoWayResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x5eda305d6b22f1f7,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x5eda305d6b22f1f7,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayFieldsResponseFut =
fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#strict_two_way_fields(&self) -> Self::StrictTwoWayFieldsResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x1323afa3e0541253,
>(_buf?)?;
Ok(_response.some_field)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
(),
0x1323afa3e0541253,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayUnionResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_union(&self) -> Self::StrictTwoWayUnionResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x68b32554eb0f6fa7,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
>(
(),
0x68b32554eb0f6fa7,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayTableResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_table(&self) -> Self::StrictTwoWayTableResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayTableResponse, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x6e4a94d44b69e785,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
>(
(),
0x6e4a94d44b69e785,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_err(&self) -> Self::StrictTwoWayErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x4fa35d5433db4d3a,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayErrResult,
>(
(),
0x4fa35d5433db4d3a,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_fields_err(&self) -> Self::StrictTwoWayFieldsErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0xb22aebf23bb58fd,
>(_buf?)?;
Ok(_response.map(|x| x.some_field))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResult,
>(
(),
0xb22aebf23bb58fd,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayUnionErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_union_err(&self) -> Self::StrictTwoWayUnionErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0xcd65d4d29a43c80,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResult,
>(
(),
0xcd65d4d29a43c80,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayTableErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_table_err(&self) -> Self::StrictTwoWayTableErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult, fidl::Error>
{
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x117dde20b92f7b90,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsClosedProtocolStrictTwoWayTableErrResult,
>(
(),
0x117dde20b92f7b90,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct UnknownInteractionsClosedProtocolEventStream {
event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}
impl std::marker::Unpin for UnknownInteractionsClosedProtocolEventStream {}
impl futures::stream::FusedStream for UnknownInteractionsClosedProtocolEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for UnknownInteractionsClosedProtocolEventStream {
type Item = Result<UnknownInteractionsClosedProtocolEvent, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
&mut self.event_receiver,
cx
)?) {
Some(buf) => {
std::task::Poll::Ready(Some(UnknownInteractionsClosedProtocolEvent::decode(buf)))
}
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum UnknownInteractionsClosedProtocolEvent {
StrictEvent {},
StrictEventFields { some_field: i32 },
StrictEventUnion { payload: UnknownInteractionsClosedProtocolStrictEventUnionRequest },
StrictEventTable { payload: UnknownInteractionsClosedProtocolStrictEventTableRequest },
}
impl UnknownInteractionsClosedProtocolEvent {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event(self) -> Option<()> {
if let UnknownInteractionsClosedProtocolEvent::StrictEvent {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_fields(self) -> Option<i32> {
if let UnknownInteractionsClosedProtocolEvent::StrictEventFields { some_field } = self {
Some((some_field))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_union(
self,
) -> Option<UnknownInteractionsClosedProtocolStrictEventUnionRequest> {
if let UnknownInteractionsClosedProtocolEvent::StrictEventUnion { payload } = self {
Some((payload))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_table(
self,
) -> Option<UnknownInteractionsClosedProtocolStrictEventTableRequest> {
if let UnknownInteractionsClosedProtocolEvent::StrictEventTable { payload } = self {
Some((payload))
} else {
None
}
}
/// Decodes a message buffer as a [`UnknownInteractionsClosedProtocolEvent`].
fn decode(
mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
) -> Result<UnknownInteractionsClosedProtocolEvent, fidl::Error> {
let (bytes, _handles) = buf.split_mut();
let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
debug_assert_eq!(tx_header.tx_id, 0);
match tx_header.ordinal {
0xa8ee6ee302f693b => {
let mut out = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsClosedProtocolEvent::StrictEvent {
}
))
}
0x5d7c57b62e9c3a74 => {
let mut out = fidl::new_empty!(UnknownInteractionsClosedProtocolStrictEventFieldsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsClosedProtocolStrictEventFieldsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsClosedProtocolEvent::StrictEventFields {some_field: out.some_field,
}
))
}
0x3b8475deeb4a9d64 => {
let mut out = fidl::new_empty!(UnknownInteractionsClosedProtocolStrictEventUnionRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsClosedProtocolStrictEventUnionRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsClosedProtocolEvent::StrictEventUnion {payload: out,
}
))
}
0x27da43fc85a7f5be => {
let mut out = fidl::new_empty!(UnknownInteractionsClosedProtocolStrictEventTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsClosedProtocolStrictEventTableRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsClosedProtocolEvent::StrictEventTable {payload: out,
}
))
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name: <UnknownInteractionsClosedProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
})
}
}
}
/// A Stream of incoming requests for test.unknowninteractions/UnknownInteractionsClosedProtocol.
pub struct UnknownInteractionsClosedProtocolRequestStream {
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
is_terminated: bool,
}
impl std::marker::Unpin for UnknownInteractionsClosedProtocolRequestStream {}
impl futures::stream::FusedStream for UnknownInteractionsClosedProtocolRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for UnknownInteractionsClosedProtocolRequestStream {
type Protocol = UnknownInteractionsClosedProtocolMarker;
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
}
fn control_handle(&self) -> Self::ControlHandle {
UnknownInteractionsClosedProtocolControlHandle { inner: self.inner.clone() }
}
fn into_inner(
self,
) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
{
(self.inner, self.is_terminated)
}
fn from_inner(
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
is_terminated: bool,
) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for UnknownInteractionsClosedProtocolRequestStream {
type Item = Result<UnknownInteractionsClosedProtocolRequest, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
let this = &mut *self;
if this.inner.check_shutdown(cx) {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
if this.is_terminated {
panic!("polled UnknownInteractionsClosedProtocolRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
|bytes, handles| {
match this.inner.channel().read_etc(cx, bytes, handles) {
std::task::Poll::Ready(Ok(())) => {}
std::task::Poll::Pending => return std::task::Poll::Pending,
std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
e.into(),
))));
}
}
// A message has been received from the channel
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x59282385962da24 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictOneWay {
control_handle,
})
}
0x5eda305d6b22f1f7 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWay {
responder: UnknownInteractionsClosedProtocolStrictTwoWayResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1323afa3e0541253 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWayFields {
responder: UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x68b32554eb0f6fa7 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWayUnion {
responder: UnknownInteractionsClosedProtocolStrictTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6e4a94d44b69e785 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWayTable {
responder: UnknownInteractionsClosedProtocolStrictTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4fa35d5433db4d3a => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWayErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xb22aebf23bb58fd => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWayFieldsErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xcd65d4d29a43c80 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWayUnionErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x117dde20b92f7b90 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsClosedProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsClosedProtocolRequest::StrictTwoWayTableErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <UnknownInteractionsClosedProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
},
)
}
}
#[derive(Debug)]
pub enum UnknownInteractionsClosedProtocolRequest {
StrictOneWay {
control_handle: UnknownInteractionsClosedProtocolControlHandle,
},
StrictTwoWay {
responder: UnknownInteractionsClosedProtocolStrictTwoWayResponder,
},
StrictTwoWayFields {
responder: UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponder,
},
StrictTwoWayUnion {
responder: UnknownInteractionsClosedProtocolStrictTwoWayUnionResponder,
},
StrictTwoWayTable {
responder: UnknownInteractionsClosedProtocolStrictTwoWayTableResponder,
},
StrictTwoWayErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayErrResponder,
},
StrictTwoWayFieldsErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponder,
},
StrictTwoWayUnionErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponder,
},
StrictTwoWayTableErr {
responder: UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponder,
},
}
impl UnknownInteractionsClosedProtocolRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_one_way(self) -> Option<(UnknownInteractionsClosedProtocolControlHandle)> {
if let UnknownInteractionsClosedProtocolRequest::StrictOneWay { control_handle } = self {
Some((control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWayFields { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWayUnion { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayTableResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWayTable { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_err(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayErrResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWayErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWayFieldsErr { responder } = self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union_err(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWayUnionErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table_err(
self,
) -> Option<(UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponder)> {
if let UnknownInteractionsClosedProtocolRequest::StrictTwoWayTableErr { responder } = self {
Some((responder))
} else {
None
}
}
/// Name of the method defined in FIDL
pub fn method_name(&self) -> &'static str {
match *self {
UnknownInteractionsClosedProtocolRequest::StrictOneWay { .. } => "strict_one_way",
UnknownInteractionsClosedProtocolRequest::StrictTwoWay { .. } => "strict_two_way",
UnknownInteractionsClosedProtocolRequest::StrictTwoWayFields { .. } => {
"strict_two_way_fields"
}
UnknownInteractionsClosedProtocolRequest::StrictTwoWayUnion { .. } => {
"strict_two_way_union"
}
UnknownInteractionsClosedProtocolRequest::StrictTwoWayTable { .. } => {
"strict_two_way_table"
}
UnknownInteractionsClosedProtocolRequest::StrictTwoWayErr { .. } => {
"strict_two_way_err"
}
UnknownInteractionsClosedProtocolRequest::StrictTwoWayFieldsErr { .. } => {
"strict_two_way_fields_err"
}
UnknownInteractionsClosedProtocolRequest::StrictTwoWayUnionErr { .. } => {
"strict_two_way_union_err"
}
UnknownInteractionsClosedProtocolRequest::StrictTwoWayTableErr { .. } => {
"strict_two_way_table_err"
}
}
}
}
#[derive(Debug, Clone)]
pub struct UnknownInteractionsClosedProtocolControlHandle {
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}
impl fidl::endpoints::ControlHandle for UnknownInteractionsClosedProtocolControlHandle {
fn shutdown(&self) {
self.inner.shutdown()
}
fn shutdown_with_epitaph(&self, status: zx_status::Status) {
self.inner.shutdown_with_epitaph(status)
}
fn is_closed(&self) -> bool {
self.inner.channel().is_closed()
}
fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
#[cfg(target_os = "fuchsia")]
fn signal_peer(
&self,
clear_mask: zx::Signals,
set_mask: zx::Signals,
) -> Result<(), zx_status::Status> {
use fidl::Peered;
self.inner.channel().signal_peer(clear_mask, set_mask)
}
}
impl UnknownInteractionsClosedProtocolControlHandle {
pub fn send_strict_event(&self) -> Result<(), fidl::Error> {
self.inner.send::<fidl::encoding::EmptyPayload>(
(),
0,
0xa8ee6ee302f693b,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_fields(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsClosedProtocolStrictEventFieldsRequest>(
(some_field,),
0,
0x5d7c57b62e9c3a74,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_union(
&self,
mut payload: &UnknownInteractionsClosedProtocolStrictEventUnionRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsClosedProtocolStrictEventUnionRequest>(
payload,
0,
0x3b8475deeb4a9d64,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_table(
&self,
mut payload: &UnknownInteractionsClosedProtocolStrictEventTableRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsClosedProtocolStrictEventTableRequest>(
payload,
0,
0x27da43fc85a7f5be,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsClosedProtocolStrictTwoWayResponder {
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x5eda305d6b22f1f7,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponder {
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>(
(some_field,),
self.tx_id,
0x1323afa3e0541253,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsClosedProtocolStrictTwoWayUnionResponder {
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayUnionResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>(
payload,
self.tx_id,
0x68b32554eb0f6fa7,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayTableResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsClosedProtocolStrictTwoWayTableResponder {
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayTableResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsClosedProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>(
payload,
self.tx_id,
0x6e4a94d44b69e785,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsClosedProtocolStrictTwoWayErrResponder {
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
result,
self.tx_id,
0x4fa35d5433db4d3a,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder
for UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponder
{
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayFieldsErrResponse,
i32,
>>(
result.map(|some_field| (some_field,)),
self.tx_id,
0xb22aebf23bb58fd,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponder {
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayUnionErrResponse,
i32,
>>(
result,
self.tx_id,
0xcd65d4d29a43c80,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsClosedProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsClosedProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponder {
type ControlHandle = UnknownInteractionsClosedProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsClosedProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsClosedProtocolStrictTwoWayTableErrResponse,
i32,
>>(
result,
self.tx_id,
0x117dde20b92f7b90,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[cfg(feature = "driver")]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct UnknownInteractionsDriverProtocolMarker;
#[cfg(feature = "driver")]
impl fidl_driver::endpoints::DriverProtocolMarker for UnknownInteractionsDriverProtocolMarker {
const DEBUG_NAME: &'static str = "(anonymous) UnknownInteractionsDriverProtocol";
}
pub type UnknownInteractionsDriverProtocolStrictTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResult =
Result<UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsDriverProtocolStrictTwoWayTableErrResult =
Result<UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse, i32>;
pub type UnknownInteractionsDriverProtocolFlexibleTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResult =
Result<UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResult =
Result<UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse, i32>;
#[cfg(feature = "driver")]
#[derive(Debug)]
pub enum UnknownInteractionsDriverProtocolRequest {
StrictOneWay {},
FlexibleOneWay {},
StrictTwoWay {
responder: UnknownInteractionsDriverProtocolStrictTwoWayResponder,
},
StrictTwoWayFields {
responder: UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponder,
},
StrictTwoWayUnion {
responder: UnknownInteractionsDriverProtocolStrictTwoWayUnionResponder,
},
StrictTwoWayTable {
responder: UnknownInteractionsDriverProtocolStrictTwoWayTableResponder,
},
StrictTwoWayErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayErrResponder,
},
StrictTwoWayFieldsErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponder,
},
StrictTwoWayUnionErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponder,
},
StrictTwoWayTableErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponder,
},
FlexibleTwoWay {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayResponder,
},
FlexibleTwoWayFields {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponder,
},
FlexibleTwoWayUnion {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponder,
},
FlexibleTwoWayTable {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponder,
},
FlexibleTwoWayErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponder,
},
FlexibleTwoWayFieldsErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponder,
},
FlexibleTwoWayUnionErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponder,
},
FlexibleTwoWayTableErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponder,
},
/// An interaction was received which does not match any known method.
#[non_exhaustive]
_UnknownMethod {
/// Ordinal of the method that was called.
ordinal: u64,
method_type: fidl::MethodType,
},
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_one_way(self) -> Option<()> {
if let UnknownInteractionsDriverProtocolRequest::StrictOneWay {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_one_way(self) -> Option<()> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleOneWay {} = self {
Some(())
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWayFields { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWayUnion { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayTableResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWayTable { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWayErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWayFieldsErr { responder } = self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWayUnionErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::StrictTwoWayTableErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_fields(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayFields { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_union(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayUnion { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_table(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayTable { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayFieldsErr { responder } =
self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_union_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayUnionErr { responder } = self
{
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_table_err(
self,
) -> Option<(UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponder)> {
if let UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayTableErr { responder } = self
{
Some((responder))
} else {
None
}
}
pub fn new_strict_one_way(self) -> Self {
Self::StrictOneWay {}
}
pub fn new_flexible_one_way(self) -> Self {
Self::FlexibleOneWay {}
}
pub fn new_strict_two_way(self, tx_id: u32) -> Self {
Self::StrictTwoWay {
responder: UnknownInteractionsDriverProtocolStrictTwoWayResponder { tx_id },
}
}
pub fn new_strict_two_way_fields(self, tx_id: u32) -> Self {
Self::StrictTwoWayFields {
responder: UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponder { tx_id },
}
}
pub fn new_strict_two_way_union(self, tx_id: u32) -> Self {
Self::StrictTwoWayUnion {
responder: UnknownInteractionsDriverProtocolStrictTwoWayUnionResponder { tx_id },
}
}
pub fn new_strict_two_way_table(self, tx_id: u32) -> Self {
Self::StrictTwoWayTable {
responder: UnknownInteractionsDriverProtocolStrictTwoWayTableResponder { tx_id },
}
}
pub fn new_strict_two_way_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayErrResponder { tx_id },
}
}
pub fn new_strict_two_way_fields_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayFieldsErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponder { tx_id },
}
}
pub fn new_strict_two_way_union_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayUnionErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponder { tx_id },
}
}
pub fn new_strict_two_way_table_err(self, tx_id: u32) -> Self {
Self::StrictTwoWayTableErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponder { tx_id },
}
}
pub fn new_flexible_two_way(self, tx_id: u32) -> Self {
Self::FlexibleTwoWay {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayResponder { tx_id },
}
}
pub fn new_flexible_two_way_fields(self, tx_id: u32) -> Self {
Self::FlexibleTwoWayFields {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponder { tx_id },
}
}
pub fn new_flexible_two_way_union(self, tx_id: u32) -> Self {
Self::FlexibleTwoWayUnion {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponder { tx_id },
}
}
pub fn new_flexible_two_way_table(self, tx_id: u32) -> Self {
Self::FlexibleTwoWayTable {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponder { tx_id },
}
}
pub fn new_flexible_two_way_err(self, tx_id: u32) -> Self {
Self::FlexibleTwoWayErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponder { tx_id },
}
}
pub fn new_flexible_two_way_fields_err(self, tx_id: u32) -> Self {
Self::FlexibleTwoWayFieldsErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponder { tx_id },
}
}
pub fn new_flexible_two_way_union_err(self, tx_id: u32) -> Self {
Self::FlexibleTwoWayUnionErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponder { tx_id },
}
}
pub fn new_flexible_two_way_table_err(self, tx_id: u32) -> Self {
Self::FlexibleTwoWayTableErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponder { tx_id },
}
}
pub fn r#strict_one_way_as_message(
arena: fdf::Arena,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let tx_id = 0;
let ordinal = 0x60e807d9431ac7e0;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_one_way_as_message(
arena: fdf::Arena,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let tx_id = 0;
let ordinal = 0xf09caab5582ac0e;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x148df9fe343291c4;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_fields_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x5ef2f222b2e8265f;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_union_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x1424d0bfc4ad422f;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_table_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x2e38ffb6ffd00589;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x721dd2e04164f9a6;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_fields_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x320bc9cd6dbe676;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_union_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x2a8fbf5a7a35ebc0;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#strict_two_way_table_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x9d3ecd1422145f1;
let dynamic_flags = fidl::encoding::DynamicFlags::empty();
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x28a750be43bf7672;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_fields_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x74e6dd972dfccce8;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_union_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x7206b28ef106b6b9;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_table_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0xe8fbdd377f4c602;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x4d7c8a333ffaee22;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_fields_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x53ba2455cd2352ab;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_union_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0x56879a1bda713fef;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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)))
})
}
pub fn r#flexible_two_way_table_err_as_message(
arena: fdf::Arena,
tx_id: u32,
) -> Result<fdf::Message<[u8]>, fidl::Error> {
let ordinal = 0xd0eb47700038400;
let dynamic_flags = fidl::encoding::DynamicFlags::FLEXIBLE;
let body = ();
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(tx_id, ordinal, dynamic_flags),
body,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
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 {
0x60e807d9431ac7e0 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictOneWay {
})
}
0xf09caab5582ac0e => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleOneWay {
})
}
0x148df9fe343291c4 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWay {
responder: UnknownInteractionsDriverProtocolStrictTwoWayResponder {
tx_id: header.tx_id,
},
})
}
0x5ef2f222b2e8265f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWayFields {
responder: UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponder {
tx_id: header.tx_id,
},
})
}
0x1424d0bfc4ad422f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWayUnion {
responder: UnknownInteractionsDriverProtocolStrictTwoWayUnionResponder {
tx_id: header.tx_id,
},
})
}
0x2e38ffb6ffd00589 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWayTable {
responder: UnknownInteractionsDriverProtocolStrictTwoWayTableResponder {
tx_id: header.tx_id,
},
})
}
0x721dd2e04164f9a6 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWayErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayErrResponder {
tx_id: header.tx_id,
},
})
}
0x320bc9cd6dbe676 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWayFieldsErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id: header.tx_id,
},
})
}
0x2a8fbf5a7a35ebc0 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWayUnionErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponder {
tx_id: header.tx_id,
},
})
}
0x9d3ecd1422145f1 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::StrictTwoWayTableErr {
responder: UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponder {
tx_id: header.tx_id,
},
})
}
0x28a750be43bf7672 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWay {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayResponder {
tx_id: header.tx_id,
},
})
}
0x74e6dd972dfccce8 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayFields {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponder {
tx_id: header.tx_id,
},
})
}
0x7206b28ef106b6b9 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayUnion {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponder {
tx_id: header.tx_id,
},
})
}
0xe8fbdd377f4c602 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayTable {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponder {
tx_id: header.tx_id,
},
})
}
0x4d7c8a333ffaee22 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponder {
tx_id: header.tx_id,
},
})
}
0x53ba2455cd2352ab => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayFieldsErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponder {
tx_id: header.tx_id,
},
})
}
0x56879a1bda713fef => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayUnionErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponder {
tx_id: header.tx_id,
},
})
}
0xd0eb47700038400 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, _handles, &mut req)?;
Ok(UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayTableErr {
responder: UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponder {
tx_id: header.tx_id,
},
})
}
_ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(UnknownInteractionsDriverProtocolRequest::_UnknownMethod {
ordinal: header.ordinal,
method_type: fidl::MethodType::OneWay,
})
}
_ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(UnknownInteractionsDriverProtocolRequest::_UnknownMethod {
ordinal: header.ordinal,
method_type: fidl::MethodType::TwoWay,
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <UnknownInteractionsDriverProtocolMarker 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 {
UnknownInteractionsDriverProtocolRequest::StrictOneWay { .. } => "strict_one_way",
UnknownInteractionsDriverProtocolRequest::FlexibleOneWay { .. } => "flexible_one_way",
UnknownInteractionsDriverProtocolRequest::StrictTwoWay { .. } => "strict_two_way",
UnknownInteractionsDriverProtocolRequest::StrictTwoWayFields { .. } => {
"strict_two_way_fields"
}
UnknownInteractionsDriverProtocolRequest::StrictTwoWayUnion { .. } => {
"strict_two_way_union"
}
UnknownInteractionsDriverProtocolRequest::StrictTwoWayTable { .. } => {
"strict_two_way_table"
}
UnknownInteractionsDriverProtocolRequest::StrictTwoWayErr { .. } => {
"strict_two_way_err"
}
UnknownInteractionsDriverProtocolRequest::StrictTwoWayFieldsErr { .. } => {
"strict_two_way_fields_err"
}
UnknownInteractionsDriverProtocolRequest::StrictTwoWayUnionErr { .. } => {
"strict_two_way_union_err"
}
UnknownInteractionsDriverProtocolRequest::StrictTwoWayTableErr { .. } => {
"strict_two_way_table_err"
}
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWay { .. } => "flexible_two_way",
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayFields { .. } => {
"flexible_two_way_fields"
}
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayUnion { .. } => {
"flexible_two_way_union"
}
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayTable { .. } => {
"flexible_two_way_table"
}
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayErr { .. } => {
"flexible_two_way_err"
}
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayFieldsErr { .. } => {
"flexible_two_way_fields_err"
}
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayUnionErr { .. } => {
"flexible_two_way_union_err"
}
UnknownInteractionsDriverProtocolRequest::FlexibleTwoWayTableErr { .. } => {
"flexible_two_way_table_err"
}
UnknownInteractionsDriverProtocolRequest::_UnknownMethod {
method_type: fidl::MethodType::OneWay,
..
} => "unknown one-way method",
UnknownInteractionsDriverProtocolRequest::_UnknownMethod {
method_type: fidl::MethodType::TwoWay,
..
} => "unknown two-way method",
}
}
}
/// Like [`UnknownInteractionsDriverProtocolRequest::read_from_message`] except it drops the [`Arena`].
#[cfg(feature = "driver")]
impl std::convert::TryFrom<fdf::Message<[u8]>> for UnknownInteractionsDriverProtocolRequest {
type Error = fidl::Error;
fn try_from(
msg: fdf::Message<[u8]>,
) -> Result<UnknownInteractionsDriverProtocolRequest, fidl::Error> {
Ok(UnknownInteractionsDriverProtocolRequest::read_from_message(msg)?.1)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayResponder {
pub fn send_response(&self, server_handle: &fdf::Channel<[u8]>) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x148df9fe343291c4,
fidl::encoding::DynamicFlags::empty(),
),
body: (),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<fidl::encoding::EmptyPayload>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut some_field: i32,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x5ef2f222b2e8265f,
fidl::encoding::DynamicFlags::empty(),
),
body: (some_field,),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayUnionResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayUnionResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x1424d0bfc4ad422f,
fidl::encoding::DynamicFlags::empty(),
),
body: payload,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayTableResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayTableResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsDriverProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x2e38ffb6ffd00589,
fidl::encoding::DynamicFlags::empty(),
),
body: payload,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
UnknownInteractionsDriverProtocolStrictTwoWayTableResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<(), i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x721dd2e04164f9a6,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<i32, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x320bc9cd6dbe676,
fidl::encoding::DynamicFlags::empty(),
),
body: result.map(|some_field| (some_field,)),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsDriverProtocolStrictTwoWayFieldsErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<&UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x2a8fbf5a7a35ebc0,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsDriverProtocolStrictTwoWayUnionErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<&UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x9d3ecd1422145f1,
fidl::encoding::DynamicFlags::empty(),
),
body: result,
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::ResultType<
UnknownInteractionsDriverProtocolStrictTwoWayTableErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayResponder {
pub fn send_response(&self, server_handle: &fdf::Channel<[u8]>) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x28a750be43bf7672,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::Flexible::new(()),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut some_field: i32,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x74e6dd972dfccce8,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::Flexible::new((some_field,)),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleType<
UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsResponse,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x7206b28ef106b6b9,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::Flexible::new(payload),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleType<
UnknownInteractionsDriverProtocolFlexibleTwoWayUnionResponse,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut payload: &UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0xe8fbdd377f4c602,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::Flexible::new(payload),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleType<
UnknownInteractionsDriverProtocolFlexibleTwoWayTableResponse,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<(), i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x4d7c8a333ffaee22,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::FlexibleResult::new(result),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<i32, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x53ba2455cd2352ab,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::FlexibleResult::new(result.map(|some_field| (some_field,))),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleResultType<
UnknownInteractionsDriverProtocolFlexibleTwoWayFieldsErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<&UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0x56879a1bda713fef,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::FlexibleResult::new(result),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleResultType<
UnknownInteractionsDriverProtocolFlexibleTwoWayUnionErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[cfg(feature = "driver")]
#[derive(Debug)]
pub struct UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponder {
tx_id: u32,
}
#[cfg(feature = "driver")]
impl UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponder {
pub fn send_response(
&self,
server_handle: &fdf::Channel<[u8]>,
mut result: Result<&UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let msg = fidl::encoding::TransactionMessage {
header: fidl::encoding::TransactionHeader::new(
self.tx_id,
0xd0eb47700038400,
fidl::encoding::DynamicFlags::FLEXIBLE,
),
body: fidl::encoding::FlexibleResult::new(result),
};
fidl::encoding::with_tls_encoded::<
fidl::encoding::TransactionMessageType<
fidl::encoding::FlexibleResultType<
UnknownInteractionsDriverProtocolFlexibleTwoWayTableErrResponse,
i32,
>,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
(),
>(msg, |body, _handles| {
server_handle
.write_with_data(fdf::Arena::new(), |arena| arena.insert_slice(&body))
.unwrap();
Ok(())
})
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct UnknownInteractionsProtocolMarker;
impl fidl::endpoints::ProtocolMarker for UnknownInteractionsProtocolMarker {
type Proxy = UnknownInteractionsProtocolProxy;
type RequestStream = UnknownInteractionsProtocolRequestStream;
#[cfg(target_os = "fuchsia")]
type SynchronousProxy = UnknownInteractionsProtocolSynchronousProxy;
const DEBUG_NAME: &'static str = "(anonymous) UnknownInteractionsProtocol";
}
pub type UnknownInteractionsProtocolStrictTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsProtocolStrictTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsProtocolStrictTwoWayUnionErrResult =
Result<UnknownInteractionsProtocolStrictTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsProtocolStrictTwoWayTableErrResult =
Result<UnknownInteractionsProtocolStrictTwoWayTableErrResponse, i32>;
pub type UnknownInteractionsProtocolFlexibleTwoWayErrResult = Result<(), i32>;
pub type UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult = Result<i32, i32>;
pub type UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult =
Result<UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse, i32>;
pub type UnknownInteractionsProtocolFlexibleTwoWayTableErrResult =
Result<UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse, i32>;
pub trait UnknownInteractionsProtocolProxyInterface: Send + Sync {
fn r#strict_one_way(&self) -> Result<(), fidl::Error>;
fn r#flexible_one_way(&self) -> Result<(), fidl::Error>;
type StrictTwoWayResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#strict_two_way(&self) -> Self::StrictTwoWayResponseFut;
type StrictTwoWayFieldsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
+ Send;
fn r#strict_two_way_fields(&self) -> Self::StrictTwoWayFieldsResponseFut;
type StrictTwoWayUnionResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolStrictTwoWayUnionResponse, fidl::Error>,
> + Send;
fn r#strict_two_way_union(&self) -> Self::StrictTwoWayUnionResponseFut;
type StrictTwoWayTableResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolStrictTwoWayTableResponse, fidl::Error>,
> + Send;
fn r#strict_two_way_table(&self) -> Self::StrictTwoWayTableResponseFut;
type StrictTwoWayErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolStrictTwoWayErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_err(&self) -> Self::StrictTwoWayErrResponseFut;
type StrictTwoWayFieldsErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolStrictTwoWayFieldsErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_fields_err(&self) -> Self::StrictTwoWayFieldsErrResponseFut;
type StrictTwoWayUnionErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolStrictTwoWayUnionErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_union_err(&self) -> Self::StrictTwoWayUnionErrResponseFut;
type StrictTwoWayTableErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolStrictTwoWayTableErrResult, fidl::Error>,
> + Send;
fn r#strict_two_way_table_err(&self) -> Self::StrictTwoWayTableErrResponseFut;
type FlexibleTwoWayResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
fn r#flexible_two_way(&self) -> Self::FlexibleTwoWayResponseFut;
type FlexibleTwoWayFieldsResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
+ Send;
fn r#flexible_two_way_fields(&self) -> Self::FlexibleTwoWayFieldsResponseFut;
type FlexibleTwoWayUnionResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolFlexibleTwoWayUnionResponse, fidl::Error>,
> + Send;
fn r#flexible_two_way_union(&self) -> Self::FlexibleTwoWayUnionResponseFut;
type FlexibleTwoWayTableResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolFlexibleTwoWayTableResponse, fidl::Error>,
> + Send;
fn r#flexible_two_way_table(&self) -> Self::FlexibleTwoWayTableResponseFut;
type FlexibleTwoWayErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolFlexibleTwoWayErrResult, fidl::Error>,
> + Send;
fn r#flexible_two_way_err(&self) -> Self::FlexibleTwoWayErrResponseFut;
type FlexibleTwoWayFieldsErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult, fidl::Error>,
> + Send;
fn r#flexible_two_way_fields_err(&self) -> Self::FlexibleTwoWayFieldsErrResponseFut;
type FlexibleTwoWayUnionErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult, fidl::Error>,
> + Send;
fn r#flexible_two_way_union_err(&self) -> Self::FlexibleTwoWayUnionErrResponseFut;
type FlexibleTwoWayTableErrResponseFut: std::future::Future<
Output = Result<UnknownInteractionsProtocolFlexibleTwoWayTableErrResult, fidl::Error>,
> + Send;
fn r#flexible_two_way_table_err(&self) -> Self::FlexibleTwoWayTableErrResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct UnknownInteractionsProtocolSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for UnknownInteractionsProtocolSynchronousProxy {
type Proxy = UnknownInteractionsProtocolProxy;
type Protocol = UnknownInteractionsProtocolMarker;
fn from_channel(inner: fidl::Channel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
fn as_channel(&self) -> &fidl::Channel {
self.client.as_channel()
}
}
#[cfg(target_os = "fuchsia")]
impl UnknownInteractionsProtocolSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<UnknownInteractionsProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
}
pub fn into_channel(self) -> fidl::Channel {
self.client.into_channel()
}
/// Waits until an event arrives and returns it. It is safe for other
/// threads to make concurrent requests while waiting for an event.
pub fn wait_for_event(
&self,
deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolEvent, fidl::Error> {
UnknownInteractionsProtocolEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x4e7273b964d117a6,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x818bb3a7a910446,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#strict_two_way(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
(),
0x734c996b0f37b942,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_fields(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<i32, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
>(
(),
0x334f4e7fff460ae3,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.some_field)
}
pub fn r#strict_two_way_union(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolStrictTwoWayUnionResponse, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayUnionResponse,
>(
(),
0x2212805eca592cad,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_table(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolStrictTwoWayTableResponse, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayTableResponse,
>(
(),
0x746ebf8659ff23b7,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response)
}
pub fn r#strict_two_way_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolStrictTwoWayErrResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(),
0x6d1c6002c51bb967,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#strict_two_way_fields_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolStrictTwoWayFieldsErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
i32,
>>(
(), 0x2182a49480e5bd2b, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x.some_field))
}
pub fn r#strict_two_way_union_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolStrictTwoWayUnionErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayUnionErrResponse,
i32,
>>(
(), 0x453af745d38b20ca, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x))
}
pub fn r#strict_two_way_table_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolStrictTwoWayTableErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayTableErrResponse,
i32,
>>(
(), 0x4c26c7ab89cb68d8, fidl::encoding::DynamicFlags::empty(), ___deadline
)?;
Ok(_response.map(|x| x))
}
pub fn r#flexible_two_way(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
>(
(),
0x4a5bb3397008b7c,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way")?;
Ok(_response)
}
pub fn r#flexible_two_way_fields(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<i32, fidl::Error> {
let _response =
self.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
>>(
(), 0x3b13f82f44813a32, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_fields")?;
Ok(_response.some_field)
}
pub fn r#flexible_two_way_union(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayUnionResponse, fidl::Error> {
let _response =
self.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
>>(
(), 0x44301e4e8d514fb6, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_union")?;
Ok(_response)
}
pub fn r#flexible_two_way_table(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayTableResponse, fidl::Error> {
let _response =
self.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
>>(
(), 0x7f492934b6c76187, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_table")?;
Ok(_response)
}
pub fn r#flexible_two_way_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayErrResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
>(
(),
0x61240f878cc37c07,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_err")?;
Ok(_response.map(|x| x))
}
pub fn r#flexible_two_way_fields_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
i32,
>>(
(), 0xf2b9611a9089b05, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_fields_err")?;
Ok(_response.map(|x| x.some_field))
}
pub fn r#flexible_two_way_union_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse,
i32,
>>(
(), 0x2172940a75f107d7, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_union_err")?;
Ok(_response.map(|x| x))
}
pub fn r#flexible_two_way_table_err(
&self,
___deadline: zx::MonotonicInstant,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayTableErrResult, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse,
i32,
>>(
(), 0x6d8aab48e1693bf2, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_table_err")?;
Ok(_response.map(|x| x))
}
}
#[cfg(target_os = "fuchsia")]
impl From<UnknownInteractionsProtocolSynchronousProxy> for zx::Handle {
fn from(value: UnknownInteractionsProtocolSynchronousProxy) -> Self {
value.into_channel().into()
}
}
#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for UnknownInteractionsProtocolSynchronousProxy {
fn from(value: fidl::Channel) -> Self {
Self::new(value)
}
}
#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for UnknownInteractionsProtocolSynchronousProxy {
type Protocol = UnknownInteractionsProtocolMarker;
fn from_client(value: fidl::endpoints::ClientEnd<UnknownInteractionsProtocolMarker>) -> Self {
Self::new(value.into_channel())
}
}
#[derive(Debug, Clone)]
pub struct UnknownInteractionsProtocolProxy {
client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}
impl fidl::endpoints::Proxy for UnknownInteractionsProtocolProxy {
type Protocol = UnknownInteractionsProtocolMarker;
fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
Self::new(inner)
}
fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
self.client.into_channel().map_err(|client| Self { client })
}
fn as_channel(&self) -> &::fidl::AsyncChannel {
self.client.as_channel()
}
}
impl UnknownInteractionsProtocolProxy {
/// Create a new Proxy for test.unknowninteractions/UnknownInteractionsProtocol.
pub fn new(channel: ::fidl::AsyncChannel) -> Self {
let protocol_name =
<UnknownInteractionsProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
/// Get a Stream of events from the remote end of the protocol.
///
/// # Panics
///
/// Panics if the event stream was already taken.
pub fn take_event_stream(&self) -> UnknownInteractionsProtocolEventStream {
UnknownInteractionsProtocolEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
UnknownInteractionsProtocolProxyInterface::r#strict_one_way(self)
}
pub fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
UnknownInteractionsProtocolProxyInterface::r#flexible_one_way(self)
}
pub fn r#strict_two_way(
&self,
) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way(self)
}
pub fn r#strict_two_way_fields(
&self,
) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way_fields(self)
}
pub fn r#strict_two_way_union(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way_union(self)
}
pub fn r#strict_two_way_table(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way_table(self)
}
pub fn r#strict_two_way_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way_err(self)
}
pub fn r#strict_two_way_fields_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way_fields_err(self)
}
pub fn r#strict_two_way_union_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way_union_err(self)
}
pub fn r#strict_two_way_table_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#strict_two_way_table_err(self)
}
pub fn r#flexible_two_way(
&self,
) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way(self)
}
pub fn r#flexible_two_way_fields(
&self,
) -> fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way_fields(self)
}
pub fn r#flexible_two_way_union(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way_union(self)
}
pub fn r#flexible_two_way_table(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way_table(self)
}
pub fn r#flexible_two_way_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way_err(self)
}
pub fn r#flexible_two_way_fields_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way_fields_err(self)
}
pub fn r#flexible_two_way_union_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way_union_err(self)
}
pub fn r#flexible_two_way_table_err(
&self,
) -> fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
> {
UnknownInteractionsProtocolProxyInterface::r#flexible_two_way_table_err(self)
}
}
impl UnknownInteractionsProtocolProxyInterface for UnknownInteractionsProtocolProxy {
fn r#strict_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x4e7273b964d117a6,
fidl::encoding::DynamicFlags::empty(),
)
}
fn r#flexible_one_way(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x818bb3a7a910446,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
type StrictTwoWayResponseFut =
fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#strict_two_way(&self) -> Self::StrictTwoWayResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::EmptyPayload,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x734c996b0f37b942,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x734c996b0f37b942,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayFieldsResponseFut =
fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#strict_two_way_fields(&self) -> Self::StrictTwoWayFieldsResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsProtocolStrictTwoWayFieldsResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x334f4e7fff460ae3,
>(_buf?)?;
Ok(_response.some_field)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
(),
0x334f4e7fff460ae3,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayUnionResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_union(&self) -> Self::StrictTwoWayUnionResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolStrictTwoWayUnionResponse, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsProtocolStrictTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x2212805eca592cad,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayUnionResponse,
>(
(),
0x2212805eca592cad,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayTableResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_table(&self) -> Self::StrictTwoWayTableResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolStrictTwoWayTableResponse, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
UnknownInteractionsProtocolStrictTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x746ebf8659ff23b7,
>(_buf?)?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayTableResponse,
>(
(),
0x746ebf8659ff23b7,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_err(&self) -> Self::StrictTwoWayErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolStrictTwoWayErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x6d1c6002c51bb967,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayErrResult,
>(
(),
0x6d1c6002c51bb967,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_fields_err(&self) -> Self::StrictTwoWayFieldsErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolStrictTwoWayFieldsErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x2182a49480e5bd2b,
>(_buf?)?;
Ok(_response.map(|x| x.some_field))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayFieldsErrResult,
>(
(),
0x2182a49480e5bd2b,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayUnionErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_union_err(&self) -> Self::StrictTwoWayUnionErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolStrictTwoWayUnionErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayUnionErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x453af745d38b20ca,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayUnionErrResult,
>(
(),
0x453af745d38b20ca,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type StrictTwoWayTableErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolStrictTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#strict_two_way_table_err(&self) -> Self::StrictTwoWayTableErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolStrictTwoWayTableErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayTableErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x4c26c7ab89cb68d8,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolStrictTwoWayTableErrResult,
>(
(),
0x4c26c7ab89cb68d8,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type FlexibleTwoWayResponseFut =
fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#flexible_two_way(&self) -> Self::FlexibleTwoWayResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x4a5bb3397008b7c,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way")?;
Ok(_response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
(),
0x4a5bb3397008b7c,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type FlexibleTwoWayFieldsResponseFut =
fidl::client::QueryResponseFut<i32, fidl::encoding::DefaultFuchsiaResourceDialect>;
fn r#flexible_two_way_fields(&self) -> Self::FlexibleTwoWayFieldsResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x3b13f82f44813a32,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_fields")?;
Ok(_response.some_field)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
(),
0x3b13f82f44813a32,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type FlexibleTwoWayUnionResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#flexible_two_way_union(&self) -> Self::FlexibleTwoWayUnionResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayUnionResponse, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x44301e4e8d514fb6,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_union")?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
>(
(),
0x44301e4e8d514fb6,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type FlexibleTwoWayTableResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#flexible_two_way_table(&self) -> Self::FlexibleTwoWayTableResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayTableResponse, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x7f492934b6c76187,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_table")?;
Ok(_response)
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
>(
(),
0x7f492934b6c76187,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type FlexibleTwoWayErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#flexible_two_way_err(&self) -> Self::FlexibleTwoWayErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x61240f878cc37c07,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_err")?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolFlexibleTwoWayErrResult,
>(
(),
0x61240f878cc37c07,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type FlexibleTwoWayFieldsErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#flexible_two_way_fields_err(&self) -> Self::FlexibleTwoWayFieldsErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0xf2b9611a9089b05,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_fields_err")?;
Ok(_response.map(|x| x.some_field))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResult,
>(
(),
0xf2b9611a9089b05,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type FlexibleTwoWayUnionErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#flexible_two_way_union_err(&self) -> Self::FlexibleTwoWayUnionErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x2172940a75f107d7,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_union_err")?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolFlexibleTwoWayUnionErrResult,
>(
(),
0x2172940a75f107d7,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type FlexibleTwoWayTableErrResponseFut = fidl::client::QueryResponseFut<
UnknownInteractionsProtocolFlexibleTwoWayTableErrResult,
fidl::encoding::DefaultFuchsiaResourceDialect,
>;
fn r#flexible_two_way_table_err(&self) -> Self::FlexibleTwoWayTableErrResponseFut {
fn _decode(
mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
) -> Result<UnknownInteractionsProtocolFlexibleTwoWayTableErrResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse,
i32,
>,
fidl::encoding::DefaultFuchsiaResourceDialect,
0x6d8aab48e1693bf2,
>(_buf?)?
.into_result::<UnknownInteractionsProtocolMarker>("flexible_two_way_table_err")?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
UnknownInteractionsProtocolFlexibleTwoWayTableErrResult,
>(
(),
0x6d8aab48e1693bf2,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
}
pub struct UnknownInteractionsProtocolEventStream {
event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}
impl std::marker::Unpin for UnknownInteractionsProtocolEventStream {}
impl futures::stream::FusedStream for UnknownInteractionsProtocolEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for UnknownInteractionsProtocolEventStream {
type Item = Result<UnknownInteractionsProtocolEvent, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
&mut self.event_receiver,
cx
)?) {
Some(buf) => {
std::task::Poll::Ready(Some(UnknownInteractionsProtocolEvent::decode(buf)))
}
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum UnknownInteractionsProtocolEvent {
StrictEvent {},
StrictEventFields {
some_field: i32,
},
StrictEventUnion {
payload: UnknownInteractionsProtocolStrictEventUnionRequest,
},
StrictEventTable {
payload: UnknownInteractionsProtocolStrictEventTableRequest,
},
FlexibleEvent {},
FlexibleEventFields {
some_field: i32,
},
FlexibleEventUnion {
payload: UnknownInteractionsProtocolFlexibleEventUnionRequest,
},
FlexibleEventTable {
payload: UnknownInteractionsProtocolFlexibleEventTableRequest,
},
#[non_exhaustive]
_UnknownEvent {
/// Ordinal of the event that was sent.
ordinal: u64,
},
}
impl UnknownInteractionsProtocolEvent {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event(self) -> Option<()> {
if let UnknownInteractionsProtocolEvent::StrictEvent {} = self { Some(()) } else { None }
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_fields(self) -> Option<i32> {
if let UnknownInteractionsProtocolEvent::StrictEventFields { some_field } = self {
Some((some_field))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_union(
self,
) -> Option<UnknownInteractionsProtocolStrictEventUnionRequest> {
if let UnknownInteractionsProtocolEvent::StrictEventUnion { payload } = self {
Some((payload))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_event_table(
self,
) -> Option<UnknownInteractionsProtocolStrictEventTableRequest> {
if let UnknownInteractionsProtocolEvent::StrictEventTable { payload } = self {
Some((payload))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event(self) -> Option<()> {
if let UnknownInteractionsProtocolEvent::FlexibleEvent {} = self { Some(()) } else { None }
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event_fields(self) -> Option<i32> {
if let UnknownInteractionsProtocolEvent::FlexibleEventFields { some_field } = self {
Some((some_field))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event_union(
self,
) -> Option<UnknownInteractionsProtocolFlexibleEventUnionRequest> {
if let UnknownInteractionsProtocolEvent::FlexibleEventUnion { payload } = self {
Some((payload))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_event_table(
self,
) -> Option<UnknownInteractionsProtocolFlexibleEventTableRequest> {
if let UnknownInteractionsProtocolEvent::FlexibleEventTable { payload } = self {
Some((payload))
} else {
None
}
}
/// Decodes a message buffer as a [`UnknownInteractionsProtocolEvent`].
fn decode(
mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
) -> Result<UnknownInteractionsProtocolEvent, fidl::Error> {
let (bytes, _handles) = buf.split_mut();
let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
debug_assert_eq!(tx_header.tx_id, 0);
match tx_header.ordinal {
0x9842669255c4fc1 => {
let mut out = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::StrictEvent {
}
))
}
0x7b75ae46520ee732 => {
let mut out = fidl::new_empty!(UnknownInteractionsProtocolStrictEventFieldsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsProtocolStrictEventFieldsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::StrictEventFields {some_field: out.some_field,
}
))
}
0x3663b5197598cbda => {
let mut out = fidl::new_empty!(UnknownInteractionsProtocolStrictEventUnionRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsProtocolStrictEventUnionRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::StrictEventUnion {payload: out,
}
))
}
0x25a10039a9f96910 => {
let mut out = fidl::new_empty!(UnknownInteractionsProtocolStrictEventTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsProtocolStrictEventTableRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::StrictEventTable {payload: out,
}
))
}
0x61bb1fab7d767866 => {
let mut out = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::FlexibleEvent {
}
))
}
0x3226dff9b0c1d801 => {
let mut out = fidl::new_empty!(UnknownInteractionsProtocolFlexibleEventFieldsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsProtocolFlexibleEventFieldsRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::FlexibleEventFields {some_field: out.some_field,
}
))
}
0x22afd161ca71e467 => {
let mut out = fidl::new_empty!(UnknownInteractionsProtocolFlexibleEventUnionRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsProtocolFlexibleEventUnionRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::FlexibleEventUnion {payload: out,
}
))
}
0x4f72dd46888b89e0 => {
let mut out = fidl::new_empty!(UnknownInteractionsProtocolFlexibleEventTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<UnknownInteractionsProtocolFlexibleEventTableRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
Ok((
UnknownInteractionsProtocolEvent::FlexibleEventTable {payload: out,
}
))
}
_ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(UnknownInteractionsProtocolEvent::_UnknownEvent {
ordinal: tx_header.ordinal,
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name: <UnknownInteractionsProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
})
}
}
}
/// A Stream of incoming requests for test.unknowninteractions/UnknownInteractionsProtocol.
pub struct UnknownInteractionsProtocolRequestStream {
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
is_terminated: bool,
}
impl std::marker::Unpin for UnknownInteractionsProtocolRequestStream {}
impl futures::stream::FusedStream for UnknownInteractionsProtocolRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for UnknownInteractionsProtocolRequestStream {
type Protocol = UnknownInteractionsProtocolMarker;
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
}
fn control_handle(&self) -> Self::ControlHandle {
UnknownInteractionsProtocolControlHandle { inner: self.inner.clone() }
}
fn into_inner(
self,
) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
{
(self.inner, self.is_terminated)
}
fn from_inner(
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
is_terminated: bool,
) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for UnknownInteractionsProtocolRequestStream {
type Item = Result<UnknownInteractionsProtocolRequest, fidl::Error>;
fn poll_next(
mut self: std::pin::Pin<&mut Self>,
cx: &mut std::task::Context<'_>,
) -> std::task::Poll<Option<Self::Item>> {
let this = &mut *self;
if this.inner.check_shutdown(cx) {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
if this.is_terminated {
panic!("polled UnknownInteractionsProtocolRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
|bytes, handles| {
match this.inner.channel().read_etc(cx, bytes, handles) {
std::task::Poll::Ready(Ok(())) => {}
std::task::Poll::Pending => return std::task::Poll::Pending,
std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
this.is_terminated = true;
return std::task::Poll::Ready(None);
}
std::task::Poll::Ready(Err(e)) => {
return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
e.into(),
))));
}
}
// A message has been received from the channel
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x4e7273b964d117a6 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictOneWay {
control_handle,
})
}
0x818bb3a7a910446 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleOneWay {
control_handle,
})
}
0x734c996b0f37b942 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWay {
responder: UnknownInteractionsProtocolStrictTwoWayResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x334f4e7fff460ae3 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWayFields {
responder: UnknownInteractionsProtocolStrictTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2212805eca592cad => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWayUnion {
responder: UnknownInteractionsProtocolStrictTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x746ebf8659ff23b7 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWayTable {
responder: UnknownInteractionsProtocolStrictTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6d1c6002c51bb967 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWayErr {
responder: UnknownInteractionsProtocolStrictTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2182a49480e5bd2b => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWayFieldsErr {
responder: UnknownInteractionsProtocolStrictTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x453af745d38b20ca => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWayUnionErr {
responder: UnknownInteractionsProtocolStrictTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4c26c7ab89cb68d8 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::StrictTwoWayTableErr {
responder: UnknownInteractionsProtocolStrictTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4a5bb3397008b7c => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWay {
responder: UnknownInteractionsProtocolFlexibleTwoWayResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x3b13f82f44813a32 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWayFields {
responder: UnknownInteractionsProtocolFlexibleTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x44301e4e8d514fb6 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWayUnion {
responder: UnknownInteractionsProtocolFlexibleTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7f492934b6c76187 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWayTable {
responder: UnknownInteractionsProtocolFlexibleTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x61240f878cc37c07 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWayErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xf2b9611a9089b05 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWayFieldsErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2172940a75f107d7 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWayUnionErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x6d8aab48e1693bf2 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
let control_handle = UnknownInteractionsProtocolControlHandle {
inner: this.inner.clone(),
};
Ok(UnknownInteractionsProtocolRequest::FlexibleTwoWayTableErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ if header.tx_id == 0 && header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(UnknownInteractionsProtocolRequest::_UnknownMethod {
ordinal: header.ordinal,
control_handle: UnknownInteractionsProtocolControlHandle { inner: this.inner.clone() },
method_type: fidl::MethodType::OneWay,
})
}
_ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
this.inner.send_framework_err(
fidl::encoding::FrameworkErr::UnknownMethod,
header.tx_id,
header.ordinal,
header.dynamic_flags(),
(bytes, handles),
)?;
Ok(UnknownInteractionsProtocolRequest::_UnknownMethod {
ordinal: header.ordinal,
control_handle: UnknownInteractionsProtocolControlHandle { inner: this.inner.clone() },
method_type: fidl::MethodType::TwoWay,
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <UnknownInteractionsProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
},
)
}
}
#[derive(Debug)]
pub enum UnknownInteractionsProtocolRequest {
StrictOneWay {
control_handle: UnknownInteractionsProtocolControlHandle,
},
FlexibleOneWay {
control_handle: UnknownInteractionsProtocolControlHandle,
},
StrictTwoWay {
responder: UnknownInteractionsProtocolStrictTwoWayResponder,
},
StrictTwoWayFields {
responder: UnknownInteractionsProtocolStrictTwoWayFieldsResponder,
},
StrictTwoWayUnion {
responder: UnknownInteractionsProtocolStrictTwoWayUnionResponder,
},
StrictTwoWayTable {
responder: UnknownInteractionsProtocolStrictTwoWayTableResponder,
},
StrictTwoWayErr {
responder: UnknownInteractionsProtocolStrictTwoWayErrResponder,
},
StrictTwoWayFieldsErr {
responder: UnknownInteractionsProtocolStrictTwoWayFieldsErrResponder,
},
StrictTwoWayUnionErr {
responder: UnknownInteractionsProtocolStrictTwoWayUnionErrResponder,
},
StrictTwoWayTableErr {
responder: UnknownInteractionsProtocolStrictTwoWayTableErrResponder,
},
FlexibleTwoWay {
responder: UnknownInteractionsProtocolFlexibleTwoWayResponder,
},
FlexibleTwoWayFields {
responder: UnknownInteractionsProtocolFlexibleTwoWayFieldsResponder,
},
FlexibleTwoWayUnion {
responder: UnknownInteractionsProtocolFlexibleTwoWayUnionResponder,
},
FlexibleTwoWayTable {
responder: UnknownInteractionsProtocolFlexibleTwoWayTableResponder,
},
FlexibleTwoWayErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayErrResponder,
},
FlexibleTwoWayFieldsErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponder,
},
FlexibleTwoWayUnionErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponder,
},
FlexibleTwoWayTableErr {
responder: UnknownInteractionsProtocolFlexibleTwoWayTableErrResponder,
},
/// An interaction was received which does not match any known method.
#[non_exhaustive]
_UnknownMethod {
/// Ordinal of the method that was called.
ordinal: u64,
control_handle: UnknownInteractionsProtocolControlHandle,
method_type: fidl::MethodType,
},
}
impl UnknownInteractionsProtocolRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_strict_one_way(self) -> Option<(UnknownInteractionsProtocolControlHandle)> {
if let UnknownInteractionsProtocolRequest::StrictOneWay { control_handle } = self {
Some((control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_one_way(self) -> Option<(UnknownInteractionsProtocolControlHandle)> {
if let UnknownInteractionsProtocolRequest::FlexibleOneWay { control_handle } = self {
Some((control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way(self) -> Option<(UnknownInteractionsProtocolStrictTwoWayResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields(
self,
) -> Option<(UnknownInteractionsProtocolStrictTwoWayFieldsResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWayFields { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union(
self,
) -> Option<(UnknownInteractionsProtocolStrictTwoWayUnionResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWayUnion { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table(
self,
) -> Option<(UnknownInteractionsProtocolStrictTwoWayTableResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWayTable { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_err(
self,
) -> Option<(UnknownInteractionsProtocolStrictTwoWayErrResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWayErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsProtocolStrictTwoWayFieldsErrResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWayFieldsErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_union_err(
self,
) -> Option<(UnknownInteractionsProtocolStrictTwoWayUnionErrResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWayUnionErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_strict_two_way_table_err(
self,
) -> Option<(UnknownInteractionsProtocolStrictTwoWayTableErrResponder)> {
if let UnknownInteractionsProtocolRequest::StrictTwoWayTableErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWay { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_fields(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayFieldsResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWayFields { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_union(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayUnionResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWayUnion { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_table(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayTableResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWayTable { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_err(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayErrResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWayErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_fields_err(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWayFieldsErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_union_err(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWayUnionErr { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_flexible_two_way_table_err(
self,
) -> Option<(UnknownInteractionsProtocolFlexibleTwoWayTableErrResponder)> {
if let UnknownInteractionsProtocolRequest::FlexibleTwoWayTableErr { responder } = self {
Some((responder))
} else {
None
}
}
/// Name of the method defined in FIDL
pub fn method_name(&self) -> &'static str {
match *self {
UnknownInteractionsProtocolRequest::StrictOneWay { .. } => "strict_one_way",
UnknownInteractionsProtocolRequest::FlexibleOneWay { .. } => "flexible_one_way",
UnknownInteractionsProtocolRequest::StrictTwoWay { .. } => "strict_two_way",
UnknownInteractionsProtocolRequest::StrictTwoWayFields { .. } => {
"strict_two_way_fields"
}
UnknownInteractionsProtocolRequest::StrictTwoWayUnion { .. } => "strict_two_way_union",
UnknownInteractionsProtocolRequest::StrictTwoWayTable { .. } => "strict_two_way_table",
UnknownInteractionsProtocolRequest::StrictTwoWayErr { .. } => "strict_two_way_err",
UnknownInteractionsProtocolRequest::StrictTwoWayFieldsErr { .. } => {
"strict_two_way_fields_err"
}
UnknownInteractionsProtocolRequest::StrictTwoWayUnionErr { .. } => {
"strict_two_way_union_err"
}
UnknownInteractionsProtocolRequest::StrictTwoWayTableErr { .. } => {
"strict_two_way_table_err"
}
UnknownInteractionsProtocolRequest::FlexibleTwoWay { .. } => "flexible_two_way",
UnknownInteractionsProtocolRequest::FlexibleTwoWayFields { .. } => {
"flexible_two_way_fields"
}
UnknownInteractionsProtocolRequest::FlexibleTwoWayUnion { .. } => {
"flexible_two_way_union"
}
UnknownInteractionsProtocolRequest::FlexibleTwoWayTable { .. } => {
"flexible_two_way_table"
}
UnknownInteractionsProtocolRequest::FlexibleTwoWayErr { .. } => "flexible_two_way_err",
UnknownInteractionsProtocolRequest::FlexibleTwoWayFieldsErr { .. } => {
"flexible_two_way_fields_err"
}
UnknownInteractionsProtocolRequest::FlexibleTwoWayUnionErr { .. } => {
"flexible_two_way_union_err"
}
UnknownInteractionsProtocolRequest::FlexibleTwoWayTableErr { .. } => {
"flexible_two_way_table_err"
}
UnknownInteractionsProtocolRequest::_UnknownMethod {
method_type: fidl::MethodType::OneWay,
..
} => "unknown one-way method",
UnknownInteractionsProtocolRequest::_UnknownMethod {
method_type: fidl::MethodType::TwoWay,
..
} => "unknown two-way method",
}
}
}
#[derive(Debug, Clone)]
pub struct UnknownInteractionsProtocolControlHandle {
inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}
impl fidl::endpoints::ControlHandle for UnknownInteractionsProtocolControlHandle {
fn shutdown(&self) {
self.inner.shutdown()
}
fn shutdown_with_epitaph(&self, status: zx_status::Status) {
self.inner.shutdown_with_epitaph(status)
}
fn is_closed(&self) -> bool {
self.inner.channel().is_closed()
}
fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
self.inner.channel().on_closed()
}
#[cfg(target_os = "fuchsia")]
fn signal_peer(
&self,
clear_mask: zx::Signals,
set_mask: zx::Signals,
) -> Result<(), zx_status::Status> {
use fidl::Peered;
self.inner.channel().signal_peer(clear_mask, set_mask)
}
}
impl UnknownInteractionsProtocolControlHandle {
pub fn send_strict_event(&self) -> Result<(), fidl::Error> {
self.inner.send::<fidl::encoding::EmptyPayload>(
(),
0,
0x9842669255c4fc1,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_fields(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsProtocolStrictEventFieldsRequest>(
(some_field,),
0,
0x7b75ae46520ee732,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_union(
&self,
mut payload: &UnknownInteractionsProtocolStrictEventUnionRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsProtocolStrictEventUnionRequest>(
payload,
0,
0x3663b5197598cbda,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_strict_event_table(
&self,
mut payload: &UnknownInteractionsProtocolStrictEventTableRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsProtocolStrictEventTableRequest>(
payload,
0,
0x25a10039a9f96910,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn send_flexible_event(&self) -> Result<(), fidl::Error> {
self.inner.send::<fidl::encoding::EmptyPayload>(
(),
0,
0x61bb1fab7d767866,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn send_flexible_event_fields(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsProtocolFlexibleEventFieldsRequest>(
(some_field,),
0,
0x3226dff9b0c1d801,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn send_flexible_event_union(
&self,
mut payload: &UnknownInteractionsProtocolFlexibleEventUnionRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsProtocolFlexibleEventUnionRequest>(
payload,
0,
0x22afd161ca71e467,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn send_flexible_event_table(
&self,
mut payload: &UnknownInteractionsProtocolFlexibleEventTableRequest,
) -> Result<(), fidl::Error> {
self.inner.send::<UnknownInteractionsProtocolFlexibleEventTableRequest>(
payload,
0,
0x4f72dd46888b89e0,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
(),
self.tx_id,
0x734c996b0f37b942,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayFieldsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayFieldsResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayFieldsResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<UnknownInteractionsProtocolStrictTwoWayFieldsResponse>(
(some_field,),
self.tx_id,
0x334f4e7fff460ae3,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayUnionResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayUnionResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayUnionResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsProtocolStrictTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<UnknownInteractionsProtocolStrictTwoWayUnionResponse>(
payload,
self.tx_id,
0x2212805eca592cad,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayTableResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayTableResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayTableResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsProtocolStrictTwoWayTableResponse,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<UnknownInteractionsProtocolStrictTwoWayTableResponse>(
payload,
self.tx_id,
0x746ebf8659ff23b7,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
result,
self.tx_id,
0x6d1c6002c51bb967,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayFieldsErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayFieldsErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayFieldsErrResponse,
i32,
>>(
result.map(|some_field| (some_field,)),
self.tx_id,
0x2182a49480e5bd2b,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayUnionErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayUnionErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayUnionErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsProtocolStrictTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayUnionErrResponse,
i32,
>>(
result,
self.tx_id,
0x453af745d38b20ca,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolStrictTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolStrictTwoWayTableErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolStrictTwoWayTableErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolStrictTwoWayTableErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsProtocolStrictTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
UnknownInteractionsProtocolStrictTwoWayTableErrResponse,
i32,
>>(
result,
self.tx_id,
0x4c26c7ab89cb68d8,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
fidl::encoding::Flexible::new(()),
self.tx_id,
0x4a5bb3397008b7c,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayFieldsResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayFieldsResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut some_field: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(some_field);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut some_field: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayFieldsResponse,
>>(
fidl::encoding::Flexible::new((some_field,)),
self.tx_id,
0x3b13f82f44813a32,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayUnionResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayUnionResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayUnionResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayUnionResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayUnionResponse,
>>(
fidl::encoding::Flexible::new(payload),
self.tx_id,
0x44301e4e8d514fb6,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayTableResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayTableResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayTableResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayTableResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut payload: &UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut payload: &UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(payload);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut payload: &UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleType<
UnknownInteractionsProtocolFlexibleTwoWayTableResponse,
>>(
fidl::encoding::Flexible::new(payload),
self.tx_id,
0x7f492934b6c76187,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
fidl::encoding::EmptyStruct,
i32,
>>(
fidl::encoding::FlexibleResult::new(result),
self.tx_id,
0x61240f878cc37c07,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<i32, i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayFieldsErrResponse,
i32,
>>(
fidl::encoding::FlexibleResult::new(result.map(|some_field| (some_field,))),
self.tx_id,
0xf2b9611a9089b05,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayUnionErrResponse,
i32,
>>(
fidl::encoding::FlexibleResult::new(result),
self.tx_id,
0x2172940a75f107d7,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct UnknownInteractionsProtocolFlexibleTwoWayTableErrResponder {
control_handle: std::mem::ManuallyDrop<UnknownInteractionsProtocolControlHandle>,
tx_id: u32,
}
/// Set the the channel to be shutdown (see [`UnknownInteractionsProtocolControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
// Safety: drops once, never accessed again
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for UnknownInteractionsProtocolFlexibleTwoWayTableErrResponder {
type ControlHandle = UnknownInteractionsProtocolControlHandle;
fn control_handle(&self) -> &UnknownInteractionsProtocolControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
// Safety: drops once, never accessed again due to mem::forget
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
// Prevent Drop from running (which would shut down the channel)
std::mem::forget(self);
}
}
impl UnknownInteractionsProtocolFlexibleTwoWayTableErrResponder {
/// Sends a response to the FIDL transaction.
///
/// Sets the channel to shutdown if an error occurs.
pub fn send(
self,
mut result: Result<&UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
/// Similar to "send" but does not shutdown the channel if an error occurs.
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<&UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse, i32>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
UnknownInteractionsProtocolFlexibleTwoWayTableErrResponse,
i32,
>>(
fidl::encoding::FlexibleResult::new(result),
self.tx_id,
0x6d8aab48e1693bf2,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
mod internal {
use super::*;
}