#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
use {
bitflags::bitflags,
fidl::{
client::QueryResponseFut,
endpoints::{ControlHandle as _, Responder as _},
},
fuchsia_zircon_status as zx_status,
futures::future::{self, MaybeDone, TryFutureExt},
};
#[cfg(target_os = "fuchsia")]
use fuchsia_zircon as zx;
pub const BIND_RULES_INSTRUCTIONS_MAX: u32 = 256;
pub const DEVICE_ARGS_MAX: u32 = 1024;
pub const DEVICE_FRAGMENT_PARTS_MAX: u32 = 16;
pub const DEVICE_FRAGMENT_PART_INSTRUCTIONS_MAX: u32 = 32;
pub const DEVICE_NAME_MAX: u32 = 31;
pub const DEVICE_PATH_MAX: u32 = 1024;
pub const FRAGMENTS_MAX: u32 = 16;
pub const FRAGMENT_NAME_MAX: u32 = 32;
pub const MAX_SCHEDULER_ROLE_LENGTH: u32 = 2048;
pub const MAX_SYSTEM_POWER_STATES: u32 = 8;
pub const METADATA_BYTES_MAX: u32 = 8192;
pub const METADATA_MAX: u32 = 32;
pub const PROPERTIES_MAX: u32 = 256;
pub const STR_LENGTH_MAX: u32 = 255;
pub const STR_PROPERTIES_MAX: u32 = 256;
bitflags! {
#[derive(Default)]
pub struct AddDeviceConfig: u32 {
const ALLOW_MULTI_COMPOSITE = 1;
const SKIP_AUTOBIND = 4;
const MUST_ISOLATE = 8;
}
}
impl AddDeviceConfig {
#[deprecated = "Strict bits should not use `has_unknown_bits`"]
#[inline(always)]
pub fn has_unknown_bits(&self) -> bool {
false
}
#[deprecated = "Strict bits should not use `get_unknown_bits`"]
#[inline(always)]
pub fn get_unknown_bits(&self) -> u32 {
0
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum SystemPowerState {
FullyOn = 1,
Reboot = 2,
RebootBootloader = 3,
RebootRecovery = 4,
Poweroff = 5,
Mexec = 6,
SuspendRam = 7,
RebootKernelInitiated = 8,
}
impl SystemPowerState {
#[inline]
pub fn from_primitive(prim: u8) -> Option<Self> {
match prim {
1 => Some(Self::FullyOn),
2 => Some(Self::Reboot),
3 => Some(Self::RebootBootloader),
4 => Some(Self::RebootRecovery),
5 => Some(Self::Poweroff),
6 => Some(Self::Mexec),
7 => Some(Self::SuspendRam),
8 => Some(Self::RebootKernelInitiated),
_ => None,
}
}
#[inline]
pub const fn into_primitive(self) -> u8 {
self as u8
}
#[deprecated = "Strict enums should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AddDeviceArgs {
pub name: String,
pub protocol_id: u32,
pub property_list: DevicePropertyList,
pub driver_path: Option<String>,
pub args: Option<String>,
pub device_add_config: AddDeviceConfig,
pub has_init: bool,
pub dfv2_device_symbol: u64,
}
impl fidl::Persistable for AddDeviceArgs {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct AdministratorUnregisterSystemStorageForShutdownResponse {
pub status: i32,
}
impl fidl::Persistable for AdministratorUnregisterSystemStorageForShutdownResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct BindInstruction {
pub op: u32,
pub arg: u32,
pub debug: u32,
}
impl fidl::Persistable for BindInstruction {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CompositeDevice {
pub fragments: Vec<Fragment>,
pub name: String,
}
impl fidl::Persistable for CompositeDevice {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CompositeDeviceDescriptor {
pub props: Vec<DeviceProperty>,
pub str_props: Vec<DeviceStrProperty>,
pub fragments: Vec<DeviceFragment>,
pub primary_fragment_index: u32,
pub spawn_colocated: bool,
pub metadata: Option<Vec<DeviceMetadata>>,
}
impl fidl::Persistable for CompositeDeviceDescriptor {}
#[derive(Clone, Debug, PartialEq)]
pub struct CompositeNodeSpecDescriptor {
pub parents: Vec<fidl_fuchsia_driver_framework::ParentSpec>,
pub metadata: Option<Vec<DeviceMetadata>>,
}
impl fidl::Persistable for CompositeNodeSpecDescriptor {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorAddCompositeDeviceRequest {
pub name: String,
pub comp_desc: CompositeDeviceDescriptor,
}
impl fidl::Persistable for CoordinatorAddCompositeDeviceRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct CoordinatorAddCompositeNodeSpecRequest {
pub name: String,
pub spec: CompositeNodeSpecDescriptor,
}
impl fidl::Persistable for CoordinatorAddCompositeNodeSpecRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorAddDeviceRequest {
pub args: AddDeviceArgs,
pub coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
pub device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
pub inspect: Option<fidl::Vmo>,
pub outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
}
impl fidl::Standalone for CoordinatorAddDeviceRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorAddMetadataRequest {
pub key: u32,
pub data: Option<Vec<u8>>,
}
impl fidl::Persistable for CoordinatorAddMetadataRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorBindDeviceRequest {
pub driver_url_suffix: Option<String>,
}
impl fidl::Persistable for CoordinatorBindDeviceRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorConnectFidlProtocolRequest {
pub fragment_name: Option<String>,
pub service_name: Option<String>,
pub protocol_name: String,
pub server: fidl::Channel,
}
impl fidl::Standalone for CoordinatorConnectFidlProtocolRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorGetMetadataRequest {
pub key: u32,
}
impl fidl::Persistable for CoordinatorGetMetadataRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorGetMetadataSizeRequest {
pub key: u32,
}
impl fidl::Persistable for CoordinatorGetMetadataSizeRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorLoadFirmwareRequest {
pub driver_path: String,
pub fw_path: String,
}
impl fidl::Persistable for CoordinatorLoadFirmwareRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorScheduleRemoveRequest {
pub unbind_self: bool,
}
impl fidl::Persistable for CoordinatorScheduleRemoveRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorAddDeviceResponse {
pub local_device_id: u64,
}
impl fidl::Persistable for CoordinatorAddDeviceResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct CoordinatorGetMetadataSizeResponse {
pub size: u64,
}
impl fidl::Persistable for CoordinatorGetMetadataSizeResponse {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorGetMetadataResponse {
pub data: Vec<u8>,
}
impl fidl::Persistable for CoordinatorGetMetadataResponse {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorGetTopologicalPathResponse {
pub path: String,
}
impl fidl::Persistable for CoordinatorGetTopologicalPathResponse {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorLoadFirmwareResponse {
pub vmo: fidl::Vmo,
pub size: u64,
}
impl fidl::Standalone for CoordinatorLoadFirmwareResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CoordinatorScheduleUnbindChildrenResponse {
pub has_children: bool,
}
impl fidl::Persistable for CoordinatorScheduleUnbindChildrenResponse {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerBindDriverRequest {
pub driver_path: String,
pub driver: fidl::Vmo,
pub default_dispatcher_scheduler_role: String,
}
impl fidl::Standalone for DeviceControllerBindDriverRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerBindDriverResponse {
pub status: i32,
pub test_output: Option<fidl::Channel>,
}
impl fidl::Standalone for DeviceControllerBindDriverResponse {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerConnectMultiplexedRequest {
pub server: fidl::Channel,
pub include_node: bool,
pub include_controller: bool,
}
impl fidl::Standalone for DeviceControllerConnectMultiplexedRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerConnectProxyRequest {
pub shadow: fidl::Channel,
}
impl fidl::Standalone for DeviceControllerConnectProxyRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerConnectToControllerRequest {
pub controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
}
impl fidl::Standalone for DeviceControllerConnectToControllerRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceControllerConnectToDeviceProtocolRequest {
pub server: fidl::Channel,
}
impl fidl::Standalone for DeviceControllerConnectToDeviceProtocolRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceControllerInitResponse {
pub status: i32,
}
impl fidl::Persistable for DeviceControllerInitResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceControllerResumeRequest {
pub target_system_state: u32,
}
impl fidl::Persistable for DeviceControllerResumeRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceControllerResumeResponse {
pub status: i32,
}
impl fidl::Persistable for DeviceControllerResumeResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceControllerSuspendRequest {
pub flags: u32,
}
impl fidl::Persistable for DeviceControllerSuspendRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceControllerSuspendResponse {
pub status: i32,
}
impl fidl::Persistable for DeviceControllerSuspendResponse {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceFragment {
pub name: String,
pub parts: Vec<DeviceFragmentPart>,
}
impl fidl::Persistable for DeviceFragment {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceFragmentPart {
pub match_program: Vec<BindInstruction>,
}
impl fidl::Persistable for DeviceFragmentPart {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceMetadata {
pub key: u32,
pub data: Vec<u8>,
}
impl fidl::Persistable for DeviceMetadata {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DeviceProperty {
pub id: u16,
pub reserved: u16,
pub value: u32,
}
impl fidl::Persistable for DeviceProperty {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DevicePropertyList {
pub props: Vec<DeviceProperty>,
pub str_props: Vec<DeviceStrProperty>,
}
impl fidl::Persistable for DevicePropertyList {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DeviceStrProperty {
pub key: String,
pub value: PropertyValue,
}
impl fidl::Persistable for DeviceStrProperty {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverHostControllerCreateDeviceRequest {
pub coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
pub device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
pub type_: DeviceType,
pub local_device_id: u64,
}
impl fidl::Standalone for DriverHostControllerCreateDeviceRequest {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DriverHostControllerCreateDeviceResponse {
pub status: i32,
}
impl fidl::Persistable for DriverHostControllerCreateDeviceResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DriverHostControllerRestartResponse {
pub status: i32,
}
impl fidl::Persistable for DriverHostControllerRestartResponse {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FidlProxyDevice {
pub incoming_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
}
impl fidl::Standalone for FidlProxyDevice {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Fragment {
pub name: String,
pub id: u64,
}
impl fidl::Persistable for Fragment {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProxyDevice {
pub driver_path: String,
pub driver: fidl::Vmo,
pub parent_proxy: fidl::Channel,
}
impl fidl::Standalone for ProxyDevice {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct StubDevice {
pub protocol_id: u32,
}
impl fidl::Persistable for StubDevice {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SystemStateTransitionGetTerminationSystemStateResponse {
pub state: SystemPowerState,
}
impl fidl::Persistable for SystemStateTransitionGetTerminationSystemStateResponse {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SystemStateTransitionGetMexecZbisResponse {
pub kernel_zbi: fidl::Vmo,
pub data_zbi: fidl::Vmo,
}
impl fidl::Standalone for SystemStateTransitionGetMexecZbisResponse {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum DeviceType {
Stub(StubDevice),
Proxy(ProxyDevice),
FidlProxy(FidlProxyDevice),
Composite(CompositeDevice),
}
impl DeviceType {
#[inline]
pub fn ordinal(&self) -> u64 {
match *self {
Self::Stub(_) => 1,
Self::Proxy(_) => 2,
Self::FidlProxy(_) => 3,
Self::Composite(_) => 4,
}
}
#[deprecated = "Strict unions should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
impl fidl::Standalone for DeviceType {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum PropertyValue {
IntValue(u32),
StrValue(String),
BoolValue(bool),
EnumValue(String),
}
impl PropertyValue {
#[inline]
pub fn ordinal(&self) -> u64 {
match *self {
Self::IntValue(_) => 1,
Self::StrValue(_) => 2,
Self::BoolValue(_) => 3,
Self::EnumValue(_) => 4,
}
}
#[deprecated = "Strict unions should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
impl fidl::Persistable for PropertyValue {}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct AdministratorMarker;
impl fidl::endpoints::ProtocolMarker for AdministratorMarker {
type Proxy = AdministratorProxy;
type RequestStream = AdministratorRequestStream;
const DEBUG_NAME: &'static str = "fuchsia.device.manager.Administrator";
}
impl fidl::endpoints::DiscoverableProtocolMarker for AdministratorMarker {}
pub trait AdministratorProxyInterface: Send + Sync {
type UnregisterSystemStorageForShutdownResponseFut: std::future::Future<Output = Result<i32, fidl::Error>>
+ Send;
fn r#unregister_system_storage_for_shutdown(
&self,
) -> Self::UnregisterSystemStorageForShutdownResponseFut;
fn r#suspend_without_exit(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct AdministratorSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl AdministratorSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name = <AdministratorMarker 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()
}
pub fn wait_for_event(&self, deadline: zx::Time) -> Result<AdministratorEvent, fidl::Error> {
AdministratorEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#unregister_system_storage_for_shutdown(
&self,
___deadline: zx::Time,
) -> Result<i32, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
AdministratorUnregisterSystemStorageForShutdownResponse,
>(
(),
0x3a423df51409d155,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.status)
}
pub fn r#suspend_without_exit(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x2607cb5dff16a5f7,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Clone)]
pub struct AdministratorProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for AdministratorProxy {
type Protocol = AdministratorMarker;
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 AdministratorProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name = <AdministratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> AdministratorEventStream {
AdministratorEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#unregister_system_storage_for_shutdown(&self) -> fidl::client::QueryResponseFut<i32> {
AdministratorProxyInterface::r#unregister_system_storage_for_shutdown(self)
}
pub fn r#suspend_without_exit(&self) -> Result<(), fidl::Error> {
AdministratorProxyInterface::r#suspend_without_exit(self)
}
}
impl AdministratorProxyInterface for AdministratorProxy {
type UnregisterSystemStorageForShutdownResponseFut = fidl::client::QueryResponseFut<i32>;
fn r#unregister_system_storage_for_shutdown(
&self,
) -> Self::UnregisterSystemStorageForShutdownResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
AdministratorUnregisterSystemStorageForShutdownResponse,
0x3a423df51409d155,
>(_buf?)?;
Ok(_response.status)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
(),
0x3a423df51409d155,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
fn r#suspend_without_exit(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0x2607cb5dff16a5f7,
fidl::encoding::DynamicFlags::empty(),
)
}
}
pub struct AdministratorEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for AdministratorEventStream {}
impl futures::stream::FusedStream for AdministratorEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for AdministratorEventStream {
type Item = Result<AdministratorEvent, 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(AdministratorEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum AdministratorEvent {}
impl AdministratorEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<AdministratorEvent, 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 {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name: <AdministratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct AdministratorRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for AdministratorRequestStream {}
impl futures::stream::FusedStream for AdministratorRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for AdministratorRequestStream {
type Protocol = AdministratorMarker;
type ControlHandle = AdministratorControlHandle;
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 {
AdministratorControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for AdministratorRequestStream {
type Item = Result<AdministratorRequest, 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 AdministratorRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|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))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x3a423df51409d155 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = AdministratorControlHandle { inner: this.inner.clone() };
Ok(AdministratorRequest::UnregisterSystemStorageForShutdown {
responder: AdministratorUnregisterSystemStorageForShutdownResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2607cb5dff16a5f7 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = AdministratorControlHandle { inner: this.inner.clone() };
Ok(AdministratorRequest::SuspendWithoutExit { control_handle })
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<AdministratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum AdministratorRequest {
UnregisterSystemStorageForShutdown {
responder: AdministratorUnregisterSystemStorageForShutdownResponder,
},
SuspendWithoutExit { control_handle: AdministratorControlHandle },
}
impl AdministratorRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_unregister_system_storage_for_shutdown(
self,
) -> Option<(AdministratorUnregisterSystemStorageForShutdownResponder)> {
if let AdministratorRequest::UnregisterSystemStorageForShutdown { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_suspend_without_exit(self) -> Option<(AdministratorControlHandle)> {
if let AdministratorRequest::SuspendWithoutExit { control_handle } = self {
Some((control_handle))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
AdministratorRequest::UnregisterSystemStorageForShutdown { .. } => {
"unregister_system_storage_for_shutdown"
}
AdministratorRequest::SuspendWithoutExit { .. } => "suspend_without_exit",
}
}
}
#[derive(Debug, Clone)]
pub struct AdministratorControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for AdministratorControlHandle {
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<'a>(&'a self) -> fidl::OnSignals<'a> {
self.inner.channel().on_closed()
}
}
impl AdministratorControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct AdministratorUnregisterSystemStorageForShutdownResponder {
control_handle: std::mem::ManuallyDrop<AdministratorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for AdministratorUnregisterSystemStorageForShutdownResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for AdministratorUnregisterSystemStorageForShutdownResponder {
type ControlHandle = AdministratorControlHandle;
fn control_handle(&self) -> &AdministratorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl AdministratorUnregisterSystemStorageForShutdownResponder {
pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<AdministratorUnregisterSystemStorageForShutdownResponse>(
(status,),
self.tx_id,
0x3a423df51409d155,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct CoordinatorMarker;
impl fidl::endpoints::ProtocolMarker for CoordinatorMarker {
type Proxy = CoordinatorProxy;
type RequestStream = CoordinatorRequestStream;
const DEBUG_NAME: &'static str = "(anonymous) Coordinator";
}
pub type CoordinatorAddDeviceResult = Result<u64, i32>;
pub type CoordinatorScheduleUnbindChildrenResult = Result<bool, i32>;
pub type CoordinatorBindDeviceResult = Result<(), i32>;
pub type CoordinatorGetTopologicalPathResult = Result<String, i32>;
pub type CoordinatorLoadFirmwareResult = Result<(fidl::Vmo, u64), i32>;
pub type CoordinatorGetMetadataResult = Result<Vec<u8>, i32>;
pub type CoordinatorGetMetadataSizeResult = Result<u64, i32>;
pub type CoordinatorAddMetadataResult = Result<(), i32>;
pub type CoordinatorAddCompositeDeviceResult = Result<(), i32>;
pub type CoordinatorAddCompositeNodeSpecResult = Result<(), i32>;
pub type CoordinatorConnectFidlProtocolResult = Result<(), i32>;
pub trait CoordinatorProxyInterface: Send + Sync {
type AddDeviceResponseFut: std::future::Future<Output = Result<CoordinatorAddDeviceResult, fidl::Error>>
+ Send;
fn r#add_device(
&self,
args: &AddDeviceArgs,
coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
inspect: Option<fidl::Vmo>,
outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
) -> Self::AddDeviceResponseFut;
fn r#schedule_remove(&self, unbind_self: bool) -> Result<(), fidl::Error>;
type ScheduleUnbindChildrenResponseFut: std::future::Future<Output = Result<CoordinatorScheduleUnbindChildrenResult, fidl::Error>>
+ Send;
fn r#schedule_unbind_children(&self) -> Self::ScheduleUnbindChildrenResponseFut;
type BindDeviceResponseFut: std::future::Future<Output = Result<CoordinatorBindDeviceResult, fidl::Error>>
+ Send;
fn r#bind_device(&self, driver_url_suffix: Option<&str>) -> Self::BindDeviceResponseFut;
type GetTopologicalPathResponseFut: std::future::Future<Output = Result<CoordinatorGetTopologicalPathResult, fidl::Error>>
+ Send;
fn r#get_topological_path(&self) -> Self::GetTopologicalPathResponseFut;
type LoadFirmwareResponseFut: std::future::Future<Output = Result<CoordinatorLoadFirmwareResult, fidl::Error>>
+ Send;
fn r#load_firmware(&self, driver_path: &str, fw_path: &str) -> Self::LoadFirmwareResponseFut;
type GetMetadataResponseFut: std::future::Future<Output = Result<CoordinatorGetMetadataResult, fidl::Error>>
+ Send;
fn r#get_metadata(&self, key: u32) -> Self::GetMetadataResponseFut;
type GetMetadataSizeResponseFut: std::future::Future<Output = Result<CoordinatorGetMetadataSizeResult, fidl::Error>>
+ Send;
fn r#get_metadata_size(&self, key: u32) -> Self::GetMetadataSizeResponseFut;
type AddMetadataResponseFut: std::future::Future<Output = Result<CoordinatorAddMetadataResult, fidl::Error>>
+ Send;
fn r#add_metadata(&self, key: u32, data: Option<&[u8]>) -> Self::AddMetadataResponseFut;
type AddCompositeDeviceResponseFut: std::future::Future<Output = Result<CoordinatorAddCompositeDeviceResult, fidl::Error>>
+ Send;
fn r#add_composite_device(
&self,
name: &str,
comp_desc: &CompositeDeviceDescriptor,
) -> Self::AddCompositeDeviceResponseFut;
type AddCompositeNodeSpecResponseFut: std::future::Future<Output = Result<CoordinatorAddCompositeNodeSpecResult, fidl::Error>>
+ Send;
fn r#add_composite_node_spec(
&self,
name: &str,
spec: &CompositeNodeSpecDescriptor,
) -> Self::AddCompositeNodeSpecResponseFut;
type ConnectFidlProtocolResponseFut: std::future::Future<Output = Result<CoordinatorConnectFidlProtocolResult, fidl::Error>>
+ Send;
fn r#connect_fidl_protocol(
&self,
fragment_name: Option<&str>,
service_name: Option<&str>,
protocol_name: &str,
server: fidl::Channel,
) -> Self::ConnectFidlProtocolResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CoordinatorSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl CoordinatorSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name = <CoordinatorMarker 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()
}
pub fn wait_for_event(&self, deadline: zx::Time) -> Result<CoordinatorEvent, fidl::Error> {
CoordinatorEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#add_device(
&self,
mut args: &AddDeviceArgs,
mut coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
mut device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
mut inspect: Option<fidl::Vmo>,
mut outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
___deadline: zx::Time,
) -> Result<CoordinatorAddDeviceResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorAddDeviceRequest,
fidl::encoding::ResultType<CoordinatorAddDeviceResponse, i32>,
>(
(args, coordinator, device_controller, inspect, outgoing_dir,),
0x2790f5d086adbf8f,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.local_device_id))
}
pub fn r#schedule_remove(&self, mut unbind_self: bool) -> Result<(), fidl::Error> {
self.client.send::<CoordinatorScheduleRemoveRequest>(
(unbind_self,),
0x1bdeb4d5d1f4d21e,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#schedule_unbind_children(
&self,
___deadline: zx::Time,
) -> Result<CoordinatorScheduleUnbindChildrenResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
CoordinatorScheduleUnbindChildrenResponse,
i32,
>>(
(),
0x658a6d68027b7139,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.has_children))
}
pub fn r#bind_device(
&self,
mut driver_url_suffix: Option<&str>,
___deadline: zx::Time,
) -> Result<CoordinatorBindDeviceResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorBindDeviceRequest,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(driver_url_suffix,),
0x274db0bd334639ca,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#get_topological_path(
&self,
___deadline: zx::Time,
) -> Result<CoordinatorGetTopologicalPathResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<CoordinatorGetTopologicalPathResponse, i32>,
>(
(),
0x319ccef1252fd6bf,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.path))
}
pub fn r#load_firmware(
&self,
mut driver_path: &str,
mut fw_path: &str,
___deadline: zx::Time,
) -> Result<CoordinatorLoadFirmwareResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorLoadFirmwareRequest,
fidl::encoding::ResultType<CoordinatorLoadFirmwareResponse, i32>,
>(
(driver_path, fw_path,),
0x5c24700e7a9815bd,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| (x.vmo, x.size)))
}
pub fn r#get_metadata(
&self,
mut key: u32,
___deadline: zx::Time,
) -> Result<CoordinatorGetMetadataResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorGetMetadataRequest,
fidl::encoding::ResultType<CoordinatorGetMetadataResponse, i32>,
>(
(key,),
0x34abe1351145bf3f,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.data))
}
pub fn r#get_metadata_size(
&self,
mut key: u32,
___deadline: zx::Time,
) -> Result<CoordinatorGetMetadataSizeResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorGetMetadataSizeRequest,
fidl::encoding::ResultType<CoordinatorGetMetadataSizeResponse, i32>,
>(
(key,),
0x290826b5b7483d61,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x.size))
}
pub fn r#add_metadata(
&self,
mut key: u32,
mut data: Option<&[u8]>,
___deadline: zx::Time,
) -> Result<CoordinatorAddMetadataResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorAddMetadataRequest,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(key, data,),
0x7acb84ea4eb23c94,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#add_composite_device(
&self,
mut name: &str,
mut comp_desc: &CompositeDeviceDescriptor,
___deadline: zx::Time,
) -> Result<CoordinatorAddCompositeDeviceResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorAddCompositeDeviceRequest,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(name, comp_desc,),
0x1610b2d89769d054,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#add_composite_node_spec(
&self,
mut name: &str,
mut spec: &CompositeNodeSpecDescriptor,
___deadline: zx::Time,
) -> Result<CoordinatorAddCompositeNodeSpecResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorAddCompositeNodeSpecRequest,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(name, spec,),
0x1ecc89bad1ab5c75,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#connect_fidl_protocol(
&self,
mut fragment_name: Option<&str>,
mut service_name: Option<&str>,
mut protocol_name: &str,
mut server: fidl::Channel,
___deadline: zx::Time,
) -> Result<CoordinatorConnectFidlProtocolResult, fidl::Error> {
let _response = self.client.send_query::<
CoordinatorConnectFidlProtocolRequest,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(fragment_name, service_name, protocol_name, server,),
0x7c9861ff4ed7fc75,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
}
#[derive(Debug, Clone)]
pub struct CoordinatorProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for CoordinatorProxy {
type Protocol = CoordinatorMarker;
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 CoordinatorProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name = <CoordinatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> CoordinatorEventStream {
CoordinatorEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#add_device(
&self,
mut args: &AddDeviceArgs,
mut coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
mut device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
mut inspect: Option<fidl::Vmo>,
mut outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
) -> fidl::client::QueryResponseFut<CoordinatorAddDeviceResult> {
CoordinatorProxyInterface::r#add_device(
self,
args,
coordinator,
device_controller,
inspect,
outgoing_dir,
)
}
pub fn r#schedule_remove(&self, mut unbind_self: bool) -> Result<(), fidl::Error> {
CoordinatorProxyInterface::r#schedule_remove(self, unbind_self)
}
pub fn r#schedule_unbind_children(
&self,
) -> fidl::client::QueryResponseFut<CoordinatorScheduleUnbindChildrenResult> {
CoordinatorProxyInterface::r#schedule_unbind_children(self)
}
pub fn r#bind_device(
&self,
mut driver_url_suffix: Option<&str>,
) -> fidl::client::QueryResponseFut<CoordinatorBindDeviceResult> {
CoordinatorProxyInterface::r#bind_device(self, driver_url_suffix)
}
pub fn r#get_topological_path(
&self,
) -> fidl::client::QueryResponseFut<CoordinatorGetTopologicalPathResult> {
CoordinatorProxyInterface::r#get_topological_path(self)
}
pub fn r#load_firmware(
&self,
mut driver_path: &str,
mut fw_path: &str,
) -> fidl::client::QueryResponseFut<CoordinatorLoadFirmwareResult> {
CoordinatorProxyInterface::r#load_firmware(self, driver_path, fw_path)
}
pub fn r#get_metadata(
&self,
mut key: u32,
) -> fidl::client::QueryResponseFut<CoordinatorGetMetadataResult> {
CoordinatorProxyInterface::r#get_metadata(self, key)
}
pub fn r#get_metadata_size(
&self,
mut key: u32,
) -> fidl::client::QueryResponseFut<CoordinatorGetMetadataSizeResult> {
CoordinatorProxyInterface::r#get_metadata_size(self, key)
}
pub fn r#add_metadata(
&self,
mut key: u32,
mut data: Option<&[u8]>,
) -> fidl::client::QueryResponseFut<CoordinatorAddMetadataResult> {
CoordinatorProxyInterface::r#add_metadata(self, key, data)
}
pub fn r#add_composite_device(
&self,
mut name: &str,
mut comp_desc: &CompositeDeviceDescriptor,
) -> fidl::client::QueryResponseFut<CoordinatorAddCompositeDeviceResult> {
CoordinatorProxyInterface::r#add_composite_device(self, name, comp_desc)
}
pub fn r#add_composite_node_spec(
&self,
mut name: &str,
mut spec: &CompositeNodeSpecDescriptor,
) -> fidl::client::QueryResponseFut<CoordinatorAddCompositeNodeSpecResult> {
CoordinatorProxyInterface::r#add_composite_node_spec(self, name, spec)
}
pub fn r#connect_fidl_protocol(
&self,
mut fragment_name: Option<&str>,
mut service_name: Option<&str>,
mut protocol_name: &str,
mut server: fidl::Channel,
) -> fidl::client::QueryResponseFut<CoordinatorConnectFidlProtocolResult> {
CoordinatorProxyInterface::r#connect_fidl_protocol(
self,
fragment_name,
service_name,
protocol_name,
server,
)
}
}
impl CoordinatorProxyInterface for CoordinatorProxy {
type AddDeviceResponseFut = fidl::client::QueryResponseFut<CoordinatorAddDeviceResult>;
fn r#add_device(
&self,
mut args: &AddDeviceArgs,
mut coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
mut device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
mut inspect: Option<fidl::Vmo>,
mut outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
) -> Self::AddDeviceResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorAddDeviceResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<CoordinatorAddDeviceResponse, i32>,
0x2790f5d086adbf8f,
>(_buf?)?;
Ok(_response.map(|x| x.local_device_id))
}
self.client
.send_query_and_decode::<CoordinatorAddDeviceRequest, CoordinatorAddDeviceResult>(
(args, coordinator, device_controller, inspect, outgoing_dir),
0x2790f5d086adbf8f,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
fn r#schedule_remove(&self, mut unbind_self: bool) -> Result<(), fidl::Error> {
self.client.send::<CoordinatorScheduleRemoveRequest>(
(unbind_self,),
0x1bdeb4d5d1f4d21e,
fidl::encoding::DynamicFlags::empty(),
)
}
type ScheduleUnbindChildrenResponseFut =
fidl::client::QueryResponseFut<CoordinatorScheduleUnbindChildrenResult>;
fn r#schedule_unbind_children(&self) -> Self::ScheduleUnbindChildrenResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorScheduleUnbindChildrenResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<CoordinatorScheduleUnbindChildrenResponse, i32>,
0x658a6d68027b7139,
>(_buf?)?;
Ok(_response.map(|x| x.has_children))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
CoordinatorScheduleUnbindChildrenResult,
>(
(),
0x658a6d68027b7139,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type BindDeviceResponseFut = fidl::client::QueryResponseFut<CoordinatorBindDeviceResult>;
fn r#bind_device(&self, mut driver_url_suffix: Option<&str>) -> Self::BindDeviceResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorBindDeviceResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x274db0bd334639ca,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client
.send_query_and_decode::<CoordinatorBindDeviceRequest, CoordinatorBindDeviceResult>(
(driver_url_suffix,),
0x274db0bd334639ca,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetTopologicalPathResponseFut =
fidl::client::QueryResponseFut<CoordinatorGetTopologicalPathResult>;
fn r#get_topological_path(&self) -> Self::GetTopologicalPathResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorGetTopologicalPathResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<CoordinatorGetTopologicalPathResponse, i32>,
0x319ccef1252fd6bf,
>(_buf?)?;
Ok(_response.map(|x| x.path))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
CoordinatorGetTopologicalPathResult,
>(
(),
0x319ccef1252fd6bf,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type LoadFirmwareResponseFut = fidl::client::QueryResponseFut<CoordinatorLoadFirmwareResult>;
fn r#load_firmware(
&self,
mut driver_path: &str,
mut fw_path: &str,
) -> Self::LoadFirmwareResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorLoadFirmwareResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<CoordinatorLoadFirmwareResponse, i32>,
0x5c24700e7a9815bd,
>(_buf?)?;
Ok(_response.map(|x| (x.vmo, x.size)))
}
self.client
.send_query_and_decode::<CoordinatorLoadFirmwareRequest, CoordinatorLoadFirmwareResult>(
(driver_path, fw_path),
0x5c24700e7a9815bd,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetMetadataResponseFut = fidl::client::QueryResponseFut<CoordinatorGetMetadataResult>;
fn r#get_metadata(&self, mut key: u32) -> Self::GetMetadataResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorGetMetadataResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<CoordinatorGetMetadataResponse, i32>,
0x34abe1351145bf3f,
>(_buf?)?;
Ok(_response.map(|x| x.data))
}
self.client
.send_query_and_decode::<CoordinatorGetMetadataRequest, CoordinatorGetMetadataResult>(
(key,),
0x34abe1351145bf3f,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetMetadataSizeResponseFut =
fidl::client::QueryResponseFut<CoordinatorGetMetadataSizeResult>;
fn r#get_metadata_size(&self, mut key: u32) -> Self::GetMetadataSizeResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorGetMetadataSizeResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<CoordinatorGetMetadataSizeResponse, i32>,
0x290826b5b7483d61,
>(_buf?)?;
Ok(_response.map(|x| x.size))
}
self.client.send_query_and_decode::<
CoordinatorGetMetadataSizeRequest,
CoordinatorGetMetadataSizeResult,
>(
(key,),
0x290826b5b7483d61,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AddMetadataResponseFut = fidl::client::QueryResponseFut<CoordinatorAddMetadataResult>;
fn r#add_metadata(
&self,
mut key: u32,
mut data: Option<&[u8]>,
) -> Self::AddMetadataResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorAddMetadataResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x7acb84ea4eb23c94,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client
.send_query_and_decode::<CoordinatorAddMetadataRequest, CoordinatorAddMetadataResult>(
(key, data),
0x7acb84ea4eb23c94,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AddCompositeDeviceResponseFut =
fidl::client::QueryResponseFut<CoordinatorAddCompositeDeviceResult>;
fn r#add_composite_device(
&self,
mut name: &str,
mut comp_desc: &CompositeDeviceDescriptor,
) -> Self::AddCompositeDeviceResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorAddCompositeDeviceResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x1610b2d89769d054,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
CoordinatorAddCompositeDeviceRequest,
CoordinatorAddCompositeDeviceResult,
>(
(name, comp_desc,),
0x1610b2d89769d054,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type AddCompositeNodeSpecResponseFut =
fidl::client::QueryResponseFut<CoordinatorAddCompositeNodeSpecResult>;
fn r#add_composite_node_spec(
&self,
mut name: &str,
mut spec: &CompositeNodeSpecDescriptor,
) -> Self::AddCompositeNodeSpecResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorAddCompositeNodeSpecResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x1ecc89bad1ab5c75,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
CoordinatorAddCompositeNodeSpecRequest,
CoordinatorAddCompositeNodeSpecResult,
>(
(name, spec,),
0x1ecc89bad1ab5c75,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ConnectFidlProtocolResponseFut =
fidl::client::QueryResponseFut<CoordinatorConnectFidlProtocolResult>;
fn r#connect_fidl_protocol(
&self,
mut fragment_name: Option<&str>,
mut service_name: Option<&str>,
mut protocol_name: &str,
mut server: fidl::Channel,
) -> Self::ConnectFidlProtocolResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<CoordinatorConnectFidlProtocolResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x7c9861ff4ed7fc75,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
CoordinatorConnectFidlProtocolRequest,
CoordinatorConnectFidlProtocolResult,
>(
(fragment_name, service_name, protocol_name, server,),
0x7c9861ff4ed7fc75,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct CoordinatorEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for CoordinatorEventStream {}
impl futures::stream::FusedStream for CoordinatorEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for CoordinatorEventStream {
type Item = Result<CoordinatorEvent, 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(CoordinatorEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum CoordinatorEvent {}
impl CoordinatorEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<CoordinatorEvent, 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 {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name: <CoordinatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct CoordinatorRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for CoordinatorRequestStream {}
impl futures::stream::FusedStream for CoordinatorRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for CoordinatorRequestStream {
type Protocol = CoordinatorMarker;
type ControlHandle = CoordinatorControlHandle;
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 {
CoordinatorControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for CoordinatorRequestStream {
type Item = Result<CoordinatorRequest, 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 CoordinatorRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|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))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x2790f5d086adbf8f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorAddDeviceRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorAddDeviceRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::AddDevice {
args: req.args,
coordinator: req.coordinator,
device_controller: req.device_controller,
inspect: req.inspect,
outgoing_dir: req.outgoing_dir,
responder: CoordinatorAddDeviceResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1bdeb4d5d1f4d21e => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(CoordinatorScheduleRemoveRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorScheduleRemoveRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::ScheduleRemove {
unbind_self: req.unbind_self,
control_handle,
})
}
0x658a6d68027b7139 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::ScheduleUnbindChildren {
responder: CoordinatorScheduleUnbindChildrenResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x274db0bd334639ca => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorBindDeviceRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorBindDeviceRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::BindDevice {
driver_url_suffix: req.driver_url_suffix,
responder: CoordinatorBindDeviceResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x319ccef1252fd6bf => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::GetTopologicalPath {
responder: CoordinatorGetTopologicalPathResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x5c24700e7a9815bd => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorLoadFirmwareRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorLoadFirmwareRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::LoadFirmware {
driver_path: req.driver_path,
fw_path: req.fw_path,
responder: CoordinatorLoadFirmwareResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x34abe1351145bf3f => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorGetMetadataRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorGetMetadataRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::GetMetadata {
key: req.key,
responder: CoordinatorGetMetadataResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x290826b5b7483d61 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorGetMetadataSizeRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorGetMetadataSizeRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::GetMetadataSize {
key: req.key,
responder: CoordinatorGetMetadataSizeResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7acb84ea4eb23c94 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorAddMetadataRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorAddMetadataRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::AddMetadata {
key: req.key,
data: req.data,
responder: CoordinatorAddMetadataResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1610b2d89769d054 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorAddCompositeDeviceRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorAddCompositeDeviceRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::AddCompositeDevice {
name: req.name,
comp_desc: req.comp_desc,
responder: CoordinatorAddCompositeDeviceResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1ecc89bad1ab5c75 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorAddCompositeNodeSpecRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorAddCompositeNodeSpecRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::AddCompositeNodeSpec {
name: req.name,
spec: req.spec,
responder: CoordinatorAddCompositeNodeSpecResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7c9861ff4ed7fc75 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(CoordinatorConnectFidlProtocolRequest);
fidl::encoding::Decoder::decode_into::<CoordinatorConnectFidlProtocolRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = CoordinatorControlHandle { inner: this.inner.clone() };
Ok(CoordinatorRequest::ConnectFidlProtocol {
fragment_name: req.fragment_name,
service_name: req.service_name,
protocol_name: req.protocol_name,
server: req.server,
responder: CoordinatorConnectFidlProtocolResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<CoordinatorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum CoordinatorRequest {
AddDevice {
args: AddDeviceArgs,
coordinator: fidl::endpoints::ServerEnd<CoordinatorMarker>,
device_controller: fidl::endpoints::ClientEnd<DeviceControllerMarker>,
inspect: Option<fidl::Vmo>,
outgoing_dir: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
responder: CoordinatorAddDeviceResponder,
},
ScheduleRemove { unbind_self: bool, control_handle: CoordinatorControlHandle },
ScheduleUnbindChildren { responder: CoordinatorScheduleUnbindChildrenResponder },
BindDevice { driver_url_suffix: Option<String>, responder: CoordinatorBindDeviceResponder },
GetTopologicalPath { responder: CoordinatorGetTopologicalPathResponder },
LoadFirmware {
driver_path: String,
fw_path: String,
responder: CoordinatorLoadFirmwareResponder,
},
GetMetadata { key: u32, responder: CoordinatorGetMetadataResponder },
GetMetadataSize { key: u32, responder: CoordinatorGetMetadataSizeResponder },
AddMetadata { key: u32, data: Option<Vec<u8>>, responder: CoordinatorAddMetadataResponder },
AddCompositeDevice {
name: String,
comp_desc: CompositeDeviceDescriptor,
responder: CoordinatorAddCompositeDeviceResponder,
},
AddCompositeNodeSpec {
name: String,
spec: CompositeNodeSpecDescriptor,
responder: CoordinatorAddCompositeNodeSpecResponder,
},
ConnectFidlProtocol {
fragment_name: Option<String>,
service_name: Option<String>,
protocol_name: String,
server: fidl::Channel,
responder: CoordinatorConnectFidlProtocolResponder,
},
}
impl CoordinatorRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_add_device(
self,
) -> Option<(
AddDeviceArgs,
fidl::endpoints::ServerEnd<CoordinatorMarker>,
fidl::endpoints::ClientEnd<DeviceControllerMarker>,
Option<fidl::Vmo>,
Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
CoordinatorAddDeviceResponder,
)> {
if let CoordinatorRequest::AddDevice {
args,
coordinator,
device_controller,
inspect,
outgoing_dir,
responder,
} = self
{
Some((args, coordinator, device_controller, inspect, outgoing_dir, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_schedule_remove(self) -> Option<(bool, CoordinatorControlHandle)> {
if let CoordinatorRequest::ScheduleRemove { unbind_self, control_handle } = self {
Some((unbind_self, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_schedule_unbind_children(
self,
) -> Option<(CoordinatorScheduleUnbindChildrenResponder)> {
if let CoordinatorRequest::ScheduleUnbindChildren { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_bind_device(self) -> Option<(Option<String>, CoordinatorBindDeviceResponder)> {
if let CoordinatorRequest::BindDevice { driver_url_suffix, responder } = self {
Some((driver_url_suffix, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_topological_path(self) -> Option<(CoordinatorGetTopologicalPathResponder)> {
if let CoordinatorRequest::GetTopologicalPath { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_load_firmware(self) -> Option<(String, String, CoordinatorLoadFirmwareResponder)> {
if let CoordinatorRequest::LoadFirmware { driver_path, fw_path, responder } = self {
Some((driver_path, fw_path, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_metadata(self) -> Option<(u32, CoordinatorGetMetadataResponder)> {
if let CoordinatorRequest::GetMetadata { key, responder } = self {
Some((key, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_metadata_size(self) -> Option<(u32, CoordinatorGetMetadataSizeResponder)> {
if let CoordinatorRequest::GetMetadataSize { key, responder } = self {
Some((key, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_add_metadata(
self,
) -> Option<(u32, Option<Vec<u8>>, CoordinatorAddMetadataResponder)> {
if let CoordinatorRequest::AddMetadata { key, data, responder } = self {
Some((key, data, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_add_composite_device(
self,
) -> Option<(String, CompositeDeviceDescriptor, CoordinatorAddCompositeDeviceResponder)> {
if let CoordinatorRequest::AddCompositeDevice { name, comp_desc, responder } = self {
Some((name, comp_desc, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_add_composite_node_spec(
self,
) -> Option<(String, CompositeNodeSpecDescriptor, CoordinatorAddCompositeNodeSpecResponder)>
{
if let CoordinatorRequest::AddCompositeNodeSpec { name, spec, responder } = self {
Some((name, spec, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect_fidl_protocol(
self,
) -> Option<(
Option<String>,
Option<String>,
String,
fidl::Channel,
CoordinatorConnectFidlProtocolResponder,
)> {
if let CoordinatorRequest::ConnectFidlProtocol {
fragment_name,
service_name,
protocol_name,
server,
responder,
} = self
{
Some((fragment_name, service_name, protocol_name, server, responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
CoordinatorRequest::AddDevice { .. } => "add_device",
CoordinatorRequest::ScheduleRemove { .. } => "schedule_remove",
CoordinatorRequest::ScheduleUnbindChildren { .. } => "schedule_unbind_children",
CoordinatorRequest::BindDevice { .. } => "bind_device",
CoordinatorRequest::GetTopologicalPath { .. } => "get_topological_path",
CoordinatorRequest::LoadFirmware { .. } => "load_firmware",
CoordinatorRequest::GetMetadata { .. } => "get_metadata",
CoordinatorRequest::GetMetadataSize { .. } => "get_metadata_size",
CoordinatorRequest::AddMetadata { .. } => "add_metadata",
CoordinatorRequest::AddCompositeDevice { .. } => "add_composite_device",
CoordinatorRequest::AddCompositeNodeSpec { .. } => "add_composite_node_spec",
CoordinatorRequest::ConnectFidlProtocol { .. } => "connect_fidl_protocol",
}
}
}
#[derive(Debug, Clone)]
pub struct CoordinatorControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for CoordinatorControlHandle {
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<'a>(&'a self) -> fidl::OnSignals<'a> {
self.inner.channel().on_closed()
}
}
impl CoordinatorControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorAddDeviceResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorAddDeviceResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorAddDeviceResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorAddDeviceResponder {
pub fn send(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<CoordinatorAddDeviceResponse, i32>>(
result.map(|local_device_id| (local_device_id,)),
self.tx_id,
0x2790f5d086adbf8f,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorScheduleUnbindChildrenResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorScheduleUnbindChildrenResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorScheduleUnbindChildrenResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorScheduleUnbindChildrenResponder {
pub fn send(self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<bool, i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
CoordinatorScheduleUnbindChildrenResponse,
i32,
>>(
result.map(|has_children| (has_children,)),
self.tx_id,
0x658a6d68027b7139,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorBindDeviceResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorBindDeviceResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorBindDeviceResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorBindDeviceResponder {
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
}
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,
0x274db0bd334639ca,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorGetTopologicalPathResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorGetTopologicalPathResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorGetTopologicalPathResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorGetTopologicalPathResponder {
pub fn send(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
CoordinatorGetTopologicalPathResponse,
i32,
>>(
result.map(|path| (path,)),
self.tx_id,
0x319ccef1252fd6bf,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorLoadFirmwareResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorLoadFirmwareResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorLoadFirmwareResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorLoadFirmwareResponder {
pub fn send(self, mut result: Result<(fidl::Vmo, u64), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<(fidl::Vmo, u64), i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(fidl::Vmo, u64), i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<CoordinatorLoadFirmwareResponse, i32>>(
result,
self.tx_id,
0x5c24700e7a9815bd,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorGetMetadataResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorGetMetadataResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorGetMetadataResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorGetMetadataResponder {
pub fn send(self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<&[u8], i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<&[u8], i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<CoordinatorGetMetadataResponse, i32>>(
result.map(|data| (data,)),
self.tx_id,
0x34abe1351145bf3f,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorGetMetadataSizeResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorGetMetadataSizeResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorGetMetadataSizeResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorGetMetadataSizeResponder {
pub fn send(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::ResultType<CoordinatorGetMetadataSizeResponse, i32>>(
result.map(|size| (size,)),
self.tx_id,
0x290826b5b7483d61,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorAddMetadataResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorAddMetadataResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorAddMetadataResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorAddMetadataResponder {
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
}
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,
0x7acb84ea4eb23c94,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorAddCompositeDeviceResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorAddCompositeDeviceResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorAddCompositeDeviceResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorAddCompositeDeviceResponder {
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
}
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,
0x1610b2d89769d054,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorAddCompositeNodeSpecResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorAddCompositeNodeSpecResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorAddCompositeNodeSpecResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorAddCompositeNodeSpecResponder {
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
}
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,
0x1ecc89bad1ab5c75,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CoordinatorConnectFidlProtocolResponder {
control_handle: std::mem::ManuallyDrop<CoordinatorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CoordinatorConnectFidlProtocolResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CoordinatorConnectFidlProtocolResponder {
type ControlHandle = CoordinatorControlHandle;
fn control_handle(&self) -> &CoordinatorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CoordinatorConnectFidlProtocolResponder {
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
}
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,
0x7c9861ff4ed7fc75,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DeviceControllerMarker;
impl fidl::endpoints::ProtocolMarker for DeviceControllerMarker {
type Proxy = DeviceControllerProxy;
type RequestStream = DeviceControllerRequestStream;
const DEBUG_NAME: &'static str = "(anonymous) DeviceController";
}
pub type DeviceControllerUnbindResult = Result<(), i32>;
pub type DeviceControllerCompleteRemovalResult = Result<(), i32>;
pub trait DeviceControllerProxyInterface: Send + Sync {
fn r#connect_multiplexed(
&self,
server: fidl::Channel,
include_node: bool,
include_controller: bool,
) -> Result<(), fidl::Error>;
fn r#connect_to_controller(
&self,
controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
) -> Result<(), fidl::Error>;
fn r#connect_to_device_protocol(&self, server: fidl::Channel) -> Result<(), fidl::Error>;
type BindDriverResponseFut: std::future::Future<Output = Result<(i32, Option<fidl::Channel>), fidl::Error>>
+ Send;
fn r#bind_driver(
&self,
driver_path: &str,
driver: fidl::Vmo,
default_dispatcher_scheduler_role: &str,
) -> Self::BindDriverResponseFut;
fn r#connect_proxy_(&self, shadow: fidl::Channel) -> Result<(), fidl::Error>;
type InitResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
fn r#init(&self) -> Self::InitResponseFut;
type UnbindResponseFut: std::future::Future<Output = Result<DeviceControllerUnbindResult, fidl::Error>>
+ Send;
fn r#unbind(&self) -> Self::UnbindResponseFut;
type CompleteRemovalResponseFut: std::future::Future<Output = Result<DeviceControllerCompleteRemovalResult, fidl::Error>>
+ Send;
fn r#complete_removal(&self) -> Self::CompleteRemovalResponseFut;
type SuspendResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
fn r#suspend(&self, flags: u32) -> Self::SuspendResponseFut;
type ResumeResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
fn r#resume(&self, target_system_state: u32) -> Self::ResumeResponseFut;
fn r#signal_made_visible(&self) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceControllerSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl DeviceControllerSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name = <DeviceControllerMarker 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()
}
pub fn wait_for_event(&self, deadline: zx::Time) -> Result<DeviceControllerEvent, fidl::Error> {
DeviceControllerEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#connect_multiplexed(
&self,
mut server: fidl::Channel,
mut include_node: bool,
mut include_controller: bool,
) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectMultiplexedRequest>(
(server, include_node, include_controller),
0x3797e17a468d5808,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#connect_to_controller(
&self,
mut controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectToControllerRequest>(
(controller,),
0x492ba92efb266b2a,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#connect_to_device_protocol(
&self,
mut server: fidl::Channel,
) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectToDeviceProtocolRequest>(
(server,),
0x65c280a3b9cb9300,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#bind_driver(
&self,
mut driver_path: &str,
mut driver: fidl::Vmo,
mut default_dispatcher_scheduler_role: &str,
___deadline: zx::Time,
) -> Result<(i32, Option<fidl::Channel>), fidl::Error> {
let _response = self
.client
.send_query::<DeviceControllerBindDriverRequest, DeviceControllerBindDriverResponse>(
(driver_path, driver, default_dispatcher_scheduler_role),
0x1600a1d1d6024855,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok((_response.status, _response.test_output))
}
pub fn r#connect_proxy_(&self, mut shadow: fidl::Channel) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectProxyRequest>(
(shadow,),
0x72206da90d1f3f2f,
fidl::encoding::DynamicFlags::empty(),
)
}
pub fn r#init(&self, ___deadline: zx::Time) -> Result<i32, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, DeviceControllerInitResponse>(
(),
0x4443bcf5eb580b37,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.status)
}
pub fn r#unbind(
&self,
___deadline: zx::Time,
) -> Result<DeviceControllerUnbindResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(),
0x2d3f793e42cc3fd0,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#complete_removal(
&self,
___deadline: zx::Time,
) -> Result<DeviceControllerCompleteRemovalResult, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
>(
(),
0x25d6d94c85d60771,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| x))
}
pub fn r#suspend(&self, mut flags: u32, ___deadline: zx::Time) -> Result<i32, fidl::Error> {
let _response = self
.client
.send_query::<DeviceControllerSuspendRequest, DeviceControllerSuspendResponse>(
(flags,),
0x77bf98a1d5d4adbb,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.status)
}
pub fn r#resume(
&self,
mut target_system_state: u32,
___deadline: zx::Time,
) -> Result<i32, fidl::Error> {
let _response = self
.client
.send_query::<DeviceControllerResumeRequest, DeviceControllerResumeResponse>(
(target_system_state,),
0x4f111286b7bd9caf,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.status)
}
pub fn r#signal_made_visible(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0xed921108aead7c5,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Clone)]
pub struct DeviceControllerProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for DeviceControllerProxy {
type Protocol = DeviceControllerMarker;
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 DeviceControllerProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name = <DeviceControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> DeviceControllerEventStream {
DeviceControllerEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#connect_multiplexed(
&self,
mut server: fidl::Channel,
mut include_node: bool,
mut include_controller: bool,
) -> Result<(), fidl::Error> {
DeviceControllerProxyInterface::r#connect_multiplexed(
self,
server,
include_node,
include_controller,
)
}
pub fn r#connect_to_controller(
&self,
mut controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
) -> Result<(), fidl::Error> {
DeviceControllerProxyInterface::r#connect_to_controller(self, controller)
}
pub fn r#connect_to_device_protocol(
&self,
mut server: fidl::Channel,
) -> Result<(), fidl::Error> {
DeviceControllerProxyInterface::r#connect_to_device_protocol(self, server)
}
pub fn r#bind_driver(
&self,
mut driver_path: &str,
mut driver: fidl::Vmo,
mut default_dispatcher_scheduler_role: &str,
) -> fidl::client::QueryResponseFut<(i32, Option<fidl::Channel>)> {
DeviceControllerProxyInterface::r#bind_driver(
self,
driver_path,
driver,
default_dispatcher_scheduler_role,
)
}
pub fn r#connect_proxy_(&self, mut shadow: fidl::Channel) -> Result<(), fidl::Error> {
DeviceControllerProxyInterface::r#connect_proxy_(self, shadow)
}
pub fn r#init(&self) -> fidl::client::QueryResponseFut<i32> {
DeviceControllerProxyInterface::r#init(self)
}
pub fn r#unbind(&self) -> fidl::client::QueryResponseFut<DeviceControllerUnbindResult> {
DeviceControllerProxyInterface::r#unbind(self)
}
pub fn r#complete_removal(
&self,
) -> fidl::client::QueryResponseFut<DeviceControllerCompleteRemovalResult> {
DeviceControllerProxyInterface::r#complete_removal(self)
}
pub fn r#suspend(&self, mut flags: u32) -> fidl::client::QueryResponseFut<i32> {
DeviceControllerProxyInterface::r#suspend(self, flags)
}
pub fn r#resume(&self, mut target_system_state: u32) -> fidl::client::QueryResponseFut<i32> {
DeviceControllerProxyInterface::r#resume(self, target_system_state)
}
pub fn r#signal_made_visible(&self) -> Result<(), fidl::Error> {
DeviceControllerProxyInterface::r#signal_made_visible(self)
}
}
impl DeviceControllerProxyInterface for DeviceControllerProxy {
fn r#connect_multiplexed(
&self,
mut server: fidl::Channel,
mut include_node: bool,
mut include_controller: bool,
) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectMultiplexedRequest>(
(server, include_node, include_controller),
0x3797e17a468d5808,
fidl::encoding::DynamicFlags::empty(),
)
}
fn r#connect_to_controller(
&self,
mut controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectToControllerRequest>(
(controller,),
0x492ba92efb266b2a,
fidl::encoding::DynamicFlags::empty(),
)
}
fn r#connect_to_device_protocol(&self, mut server: fidl::Channel) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectToDeviceProtocolRequest>(
(server,),
0x65c280a3b9cb9300,
fidl::encoding::DynamicFlags::empty(),
)
}
type BindDriverResponseFut = fidl::client::QueryResponseFut<(i32, Option<fidl::Channel>)>;
fn r#bind_driver(
&self,
mut driver_path: &str,
mut driver: fidl::Vmo,
mut default_dispatcher_scheduler_role: &str,
) -> Self::BindDriverResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<(i32, Option<fidl::Channel>), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DeviceControllerBindDriverResponse,
0x1600a1d1d6024855,
>(_buf?)?;
Ok((_response.status, _response.test_output))
}
self.client.send_query_and_decode::<
DeviceControllerBindDriverRequest,
(i32, Option<fidl::Channel>),
>(
(driver_path, driver, default_dispatcher_scheduler_role,),
0x1600a1d1d6024855,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
fn r#connect_proxy_(&self, mut shadow: fidl::Channel) -> Result<(), fidl::Error> {
self.client.send::<DeviceControllerConnectProxyRequest>(
(shadow,),
0x72206da90d1f3f2f,
fidl::encoding::DynamicFlags::empty(),
)
}
type InitResponseFut = fidl::client::QueryResponseFut<i32>;
fn r#init(&self) -> Self::InitResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DeviceControllerInitResponse,
0x4443bcf5eb580b37,
>(_buf?)?;
Ok(_response.status)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
(),
0x4443bcf5eb580b37,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type UnbindResponseFut = fidl::client::QueryResponseFut<DeviceControllerUnbindResult>;
fn r#unbind(&self) -> Self::UnbindResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DeviceControllerUnbindResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x2d3f793e42cc3fd0,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client
.send_query_and_decode::<fidl::encoding::EmptyPayload, DeviceControllerUnbindResult>(
(),
0x2d3f793e42cc3fd0,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type CompleteRemovalResponseFut =
fidl::client::QueryResponseFut<DeviceControllerCompleteRemovalResult>;
fn r#complete_removal(&self) -> Self::CompleteRemovalResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DeviceControllerCompleteRemovalResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
0x25d6d94c85d60771,
>(_buf?)?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
DeviceControllerCompleteRemovalResult,
>(
(),
0x25d6d94c85d60771,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type SuspendResponseFut = fidl::client::QueryResponseFut<i32>;
fn r#suspend(&self, mut flags: u32) -> Self::SuspendResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DeviceControllerSuspendResponse,
0x77bf98a1d5d4adbb,
>(_buf?)?;
Ok(_response.status)
}
self.client.send_query_and_decode::<DeviceControllerSuspendRequest, i32>(
(flags,),
0x77bf98a1d5d4adbb,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type ResumeResponseFut = fidl::client::QueryResponseFut<i32>;
fn r#resume(&self, mut target_system_state: u32) -> Self::ResumeResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DeviceControllerResumeResponse,
0x4f111286b7bd9caf,
>(_buf?)?;
Ok(_response.status)
}
self.client.send_query_and_decode::<DeviceControllerResumeRequest, i32>(
(target_system_state,),
0x4f111286b7bd9caf,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
fn r#signal_made_visible(&self) -> Result<(), fidl::Error> {
self.client.send::<fidl::encoding::EmptyPayload>(
(),
0xed921108aead7c5,
fidl::encoding::DynamicFlags::empty(),
)
}
}
pub struct DeviceControllerEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for DeviceControllerEventStream {}
impl futures::stream::FusedStream for DeviceControllerEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for DeviceControllerEventStream {
type Item = Result<DeviceControllerEvent, 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(DeviceControllerEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum DeviceControllerEvent {}
impl DeviceControllerEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<DeviceControllerEvent, 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 {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<DeviceControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct DeviceControllerRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for DeviceControllerRequestStream {}
impl futures::stream::FusedStream for DeviceControllerRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for DeviceControllerRequestStream {
type Protocol = DeviceControllerMarker;
type ControlHandle = DeviceControllerControlHandle;
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 {
DeviceControllerControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for DeviceControllerRequestStream {
type Item = Result<DeviceControllerRequest, 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 DeviceControllerRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|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))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x3797e17a468d5808 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DeviceControllerConnectMultiplexedRequest);
fidl::encoding::Decoder::decode_into::<
DeviceControllerConnectMultiplexedRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::ConnectMultiplexed {
server: req.server,
include_node: req.include_node,
include_controller: req.include_controller,
control_handle,
})
}
0x492ba92efb266b2a => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DeviceControllerConnectToControllerRequest);
fidl::encoding::Decoder::decode_into::<
DeviceControllerConnectToControllerRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::ConnectToController {
controller: req.controller,
control_handle,
})
}
0x65c280a3b9cb9300 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DeviceControllerConnectToDeviceProtocolRequest);
fidl::encoding::Decoder::decode_into::<
DeviceControllerConnectToDeviceProtocolRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::ConnectToDeviceProtocol {
server: req.server,
control_handle,
})
}
0x1600a1d1d6024855 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DeviceControllerBindDriverRequest);
fidl::encoding::Decoder::decode_into::<DeviceControllerBindDriverRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::BindDriver {
driver_path: req.driver_path,
driver: req.driver,
default_dispatcher_scheduler_role: req.default_dispatcher_scheduler_role,
responder: DeviceControllerBindDriverResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x72206da90d1f3f2f => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DeviceControllerConnectProxyRequest);
fidl::encoding::Decoder::decode_into::<DeviceControllerConnectProxyRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::ConnectProxy_ {
shadow: req.shadow,
control_handle,
})
}
0x4443bcf5eb580b37 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::Init {
responder: DeviceControllerInitResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x2d3f793e42cc3fd0 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::Unbind {
responder: DeviceControllerUnbindResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x25d6d94c85d60771 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::CompleteRemoval {
responder: DeviceControllerCompleteRemovalResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x77bf98a1d5d4adbb => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DeviceControllerSuspendRequest);
fidl::encoding::Decoder::decode_into::<DeviceControllerSuspendRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::Suspend {
flags: req.flags,
responder: DeviceControllerSuspendResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4f111286b7bd9caf => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DeviceControllerResumeRequest);
fidl::encoding::Decoder::decode_into::<DeviceControllerResumeRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::Resume {
target_system_state: req.target_system_state,
responder: DeviceControllerResumeResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0xed921108aead7c5 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DeviceControllerControlHandle { inner: this.inner.clone() };
Ok(DeviceControllerRequest::SignalMadeVisible { control_handle })
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<DeviceControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum DeviceControllerRequest {
ConnectMultiplexed {
server: fidl::Channel,
include_node: bool,
include_controller: bool,
control_handle: DeviceControllerControlHandle,
},
ConnectToController {
controller: fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
control_handle: DeviceControllerControlHandle,
},
ConnectToDeviceProtocol { server: fidl::Channel, control_handle: DeviceControllerControlHandle },
BindDriver {
driver_path: String,
driver: fidl::Vmo,
default_dispatcher_scheduler_role: String,
responder: DeviceControllerBindDriverResponder,
},
ConnectProxy_ { shadow: fidl::Channel, control_handle: DeviceControllerControlHandle },
Init { responder: DeviceControllerInitResponder },
Unbind { responder: DeviceControllerUnbindResponder },
CompleteRemoval { responder: DeviceControllerCompleteRemovalResponder },
Suspend { flags: u32, responder: DeviceControllerSuspendResponder },
Resume { target_system_state: u32, responder: DeviceControllerResumeResponder },
SignalMadeVisible { control_handle: DeviceControllerControlHandle },
}
impl DeviceControllerRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_connect_multiplexed(
self,
) -> Option<(fidl::Channel, bool, bool, DeviceControllerControlHandle)> {
if let DeviceControllerRequest::ConnectMultiplexed {
server,
include_node,
include_controller,
control_handle,
} = self
{
Some((server, include_node, include_controller, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect_to_controller(
self,
) -> Option<(
fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
DeviceControllerControlHandle,
)> {
if let DeviceControllerRequest::ConnectToController { controller, control_handle } = self {
Some((controller, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect_to_device_protocol(
self,
) -> Option<(fidl::Channel, DeviceControllerControlHandle)> {
if let DeviceControllerRequest::ConnectToDeviceProtocol { server, control_handle } = self {
Some((server, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_bind_driver(
self,
) -> Option<(String, fidl::Vmo, String, DeviceControllerBindDriverResponder)> {
if let DeviceControllerRequest::BindDriver {
driver_path,
driver,
default_dispatcher_scheduler_role,
responder,
} = self
{
Some((driver_path, driver, default_dispatcher_scheduler_role, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_connect_proxy_(self) -> Option<(fidl::Channel, DeviceControllerControlHandle)> {
if let DeviceControllerRequest::ConnectProxy_ { shadow, control_handle } = self {
Some((shadow, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_init(self) -> Option<(DeviceControllerInitResponder)> {
if let DeviceControllerRequest::Init { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_unbind(self) -> Option<(DeviceControllerUnbindResponder)> {
if let DeviceControllerRequest::Unbind { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_complete_removal(self) -> Option<(DeviceControllerCompleteRemovalResponder)> {
if let DeviceControllerRequest::CompleteRemoval { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_suspend(self) -> Option<(u32, DeviceControllerSuspendResponder)> {
if let DeviceControllerRequest::Suspend { flags, responder } = self {
Some((flags, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_resume(self) -> Option<(u32, DeviceControllerResumeResponder)> {
if let DeviceControllerRequest::Resume { target_system_state, responder } = self {
Some((target_system_state, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_signal_made_visible(self) -> Option<(DeviceControllerControlHandle)> {
if let DeviceControllerRequest::SignalMadeVisible { control_handle } = self {
Some((control_handle))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
DeviceControllerRequest::ConnectMultiplexed { .. } => "connect_multiplexed",
DeviceControllerRequest::ConnectToController { .. } => "connect_to_controller",
DeviceControllerRequest::ConnectToDeviceProtocol { .. } => "connect_to_device_protocol",
DeviceControllerRequest::BindDriver { .. } => "bind_driver",
DeviceControllerRequest::ConnectProxy_ { .. } => "connect_proxy_",
DeviceControllerRequest::Init { .. } => "init",
DeviceControllerRequest::Unbind { .. } => "unbind",
DeviceControllerRequest::CompleteRemoval { .. } => "complete_removal",
DeviceControllerRequest::Suspend { .. } => "suspend",
DeviceControllerRequest::Resume { .. } => "resume",
DeviceControllerRequest::SignalMadeVisible { .. } => "signal_made_visible",
}
}
}
#[derive(Debug, Clone)]
pub struct DeviceControllerControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for DeviceControllerControlHandle {
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<'a>(&'a self) -> fidl::OnSignals<'a> {
self.inner.channel().on_closed()
}
}
impl DeviceControllerControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceControllerBindDriverResponder {
control_handle: std::mem::ManuallyDrop<DeviceControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DeviceControllerBindDriverResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DeviceControllerBindDriverResponder {
type ControlHandle = DeviceControllerControlHandle;
fn control_handle(&self) -> &DeviceControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DeviceControllerBindDriverResponder {
pub fn send(
self,
mut status: i32,
mut test_output: Option<fidl::Channel>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(status, test_output);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut status: i32,
mut test_output: Option<fidl::Channel>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(status, test_output);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut status: i32,
mut test_output: Option<fidl::Channel>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DeviceControllerBindDriverResponse>(
(status, test_output),
self.tx_id,
0x1600a1d1d6024855,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceControllerInitResponder {
control_handle: std::mem::ManuallyDrop<DeviceControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DeviceControllerInitResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DeviceControllerInitResponder {
type ControlHandle = DeviceControllerControlHandle;
fn control_handle(&self) -> &DeviceControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DeviceControllerInitResponder {
pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DeviceControllerInitResponse>(
(status,),
self.tx_id,
0x4443bcf5eb580b37,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceControllerUnbindResponder {
control_handle: std::mem::ManuallyDrop<DeviceControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DeviceControllerUnbindResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DeviceControllerUnbindResponder {
type ControlHandle = DeviceControllerControlHandle;
fn control_handle(&self) -> &DeviceControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DeviceControllerUnbindResponder {
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
}
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,
0x2d3f793e42cc3fd0,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceControllerCompleteRemovalResponder {
control_handle: std::mem::ManuallyDrop<DeviceControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DeviceControllerCompleteRemovalResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DeviceControllerCompleteRemovalResponder {
type ControlHandle = DeviceControllerControlHandle;
fn control_handle(&self) -> &DeviceControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DeviceControllerCompleteRemovalResponder {
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
}
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,
0x25d6d94c85d60771,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceControllerSuspendResponder {
control_handle: std::mem::ManuallyDrop<DeviceControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DeviceControllerSuspendResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DeviceControllerSuspendResponder {
type ControlHandle = DeviceControllerControlHandle;
fn control_handle(&self) -> &DeviceControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DeviceControllerSuspendResponder {
pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DeviceControllerSuspendResponse>(
(status,),
self.tx_id,
0x77bf98a1d5d4adbb,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceControllerResumeResponder {
control_handle: std::mem::ManuallyDrop<DeviceControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DeviceControllerResumeResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DeviceControllerResumeResponder {
type ControlHandle = DeviceControllerControlHandle;
fn control_handle(&self) -> &DeviceControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DeviceControllerResumeResponder {
pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DeviceControllerResumeResponse>(
(status,),
self.tx_id,
0x4f111286b7bd9caf,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverHostControllerMarker;
impl fidl::endpoints::ProtocolMarker for DriverHostControllerMarker {
type Proxy = DriverHostControllerProxy;
type RequestStream = DriverHostControllerRequestStream;
const DEBUG_NAME: &'static str = "(anonymous) DriverHostController";
}
pub trait DriverHostControllerProxyInterface: Send + Sync {
type CreateDeviceResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
fn r#create_device(
&self,
coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
type_: DeviceType,
local_device_id: u64,
) -> Self::CreateDeviceResponseFut;
type RestartResponseFut: std::future::Future<Output = Result<i32, fidl::Error>> + Send;
fn r#restart(&self) -> Self::RestartResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DriverHostControllerSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl DriverHostControllerSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<DriverHostControllerMarker 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()
}
pub fn wait_for_event(
&self,
deadline: zx::Time,
) -> Result<DriverHostControllerEvent, fidl::Error> {
DriverHostControllerEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#create_device(
&self,
mut coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
mut device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
mut type_: DeviceType,
mut local_device_id: u64,
___deadline: zx::Time,
) -> Result<i32, fidl::Error> {
let _response = self.client.send_query::<
DriverHostControllerCreateDeviceRequest,
DriverHostControllerCreateDeviceResponse,
>(
(coordinator, device_controller, &mut type_, local_device_id,),
0x5d136e167043e7de,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.status)
}
pub fn r#restart(&self, ___deadline: zx::Time) -> Result<i32, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, DriverHostControllerRestartResponse>(
(),
0x1a870ec87b9fa33d,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.status)
}
}
#[derive(Debug, Clone)]
pub struct DriverHostControllerProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for DriverHostControllerProxy {
type Protocol = DriverHostControllerMarker;
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 DriverHostControllerProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<DriverHostControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> DriverHostControllerEventStream {
DriverHostControllerEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#create_device(
&self,
mut coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
mut device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
mut type_: DeviceType,
mut local_device_id: u64,
) -> fidl::client::QueryResponseFut<i32> {
DriverHostControllerProxyInterface::r#create_device(
self,
coordinator,
device_controller,
type_,
local_device_id,
)
}
pub fn r#restart(&self) -> fidl::client::QueryResponseFut<i32> {
DriverHostControllerProxyInterface::r#restart(self)
}
}
impl DriverHostControllerProxyInterface for DriverHostControllerProxy {
type CreateDeviceResponseFut = fidl::client::QueryResponseFut<i32>;
fn r#create_device(
&self,
mut coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
mut device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
mut type_: DeviceType,
mut local_device_id: u64,
) -> Self::CreateDeviceResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DriverHostControllerCreateDeviceResponse,
0x5d136e167043e7de,
>(_buf?)?;
Ok(_response.status)
}
self.client.send_query_and_decode::<DriverHostControllerCreateDeviceRequest, i32>(
(coordinator, device_controller, &mut type_, local_device_id),
0x5d136e167043e7de,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type RestartResponseFut = fidl::client::QueryResponseFut<i32>;
fn r#restart(&self) -> Self::RestartResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<i32, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DriverHostControllerRestartResponse,
0x1a870ec87b9fa33d,
>(_buf?)?;
Ok(_response.status)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, i32>(
(),
0x1a870ec87b9fa33d,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct DriverHostControllerEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for DriverHostControllerEventStream {}
impl futures::stream::FusedStream for DriverHostControllerEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for DriverHostControllerEventStream {
type Item = Result<DriverHostControllerEvent, 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(DriverHostControllerEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum DriverHostControllerEvent {}
impl DriverHostControllerEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<DriverHostControllerEvent, 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 {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<DriverHostControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct DriverHostControllerRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for DriverHostControllerRequestStream {}
impl futures::stream::FusedStream for DriverHostControllerRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for DriverHostControllerRequestStream {
type Protocol = DriverHostControllerMarker;
type ControlHandle = DriverHostControllerControlHandle;
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 {
DriverHostControllerControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for DriverHostControllerRequestStream {
type Item = Result<DriverHostControllerRequest, 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 DriverHostControllerRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|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))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x5d136e167043e7de => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverHostControllerCreateDeviceRequest);
fidl::encoding::Decoder::decode_into::<DriverHostControllerCreateDeviceRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverHostControllerControlHandle { inner: this.inner.clone() };
Ok(DriverHostControllerRequest::CreateDevice {
coordinator: req.coordinator,
device_controller: req.device_controller,
type_: req.type_,
local_device_id: req.local_device_id,
responder: DriverHostControllerCreateDeviceResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1a870ec87b9fa33d => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverHostControllerControlHandle { inner: this.inner.clone() };
Ok(DriverHostControllerRequest::Restart {
responder: DriverHostControllerRestartResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<DriverHostControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum DriverHostControllerRequest {
CreateDevice {
coordinator: fidl::endpoints::ClientEnd<CoordinatorMarker>,
device_controller: fidl::endpoints::ServerEnd<DeviceControllerMarker>,
type_: DeviceType,
local_device_id: u64,
responder: DriverHostControllerCreateDeviceResponder,
},
Restart { responder: DriverHostControllerRestartResponder },
}
impl DriverHostControllerRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_create_device(
self,
) -> Option<(
fidl::endpoints::ClientEnd<CoordinatorMarker>,
fidl::endpoints::ServerEnd<DeviceControllerMarker>,
DeviceType,
u64,
DriverHostControllerCreateDeviceResponder,
)> {
if let DriverHostControllerRequest::CreateDevice {
coordinator,
device_controller,
type_,
local_device_id,
responder,
} = self
{
Some((coordinator, device_controller, type_, local_device_id, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_restart(self) -> Option<(DriverHostControllerRestartResponder)> {
if let DriverHostControllerRequest::Restart { responder } = self {
Some((responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
DriverHostControllerRequest::CreateDevice { .. } => "create_device",
DriverHostControllerRequest::Restart { .. } => "restart",
}
}
}
#[derive(Debug, Clone)]
pub struct DriverHostControllerControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for DriverHostControllerControlHandle {
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<'a>(&'a self) -> fidl::OnSignals<'a> {
self.inner.channel().on_closed()
}
}
impl DriverHostControllerControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverHostControllerCreateDeviceResponder {
control_handle: std::mem::ManuallyDrop<DriverHostControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverHostControllerCreateDeviceResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverHostControllerCreateDeviceResponder {
type ControlHandle = DriverHostControllerControlHandle;
fn control_handle(&self) -> &DriverHostControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverHostControllerCreateDeviceResponder {
pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DriverHostControllerCreateDeviceResponse>(
(status,),
self.tx_id,
0x5d136e167043e7de,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverHostControllerRestartResponder {
control_handle: std::mem::ManuallyDrop<DriverHostControllerControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverHostControllerRestartResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverHostControllerRestartResponder {
type ControlHandle = DriverHostControllerControlHandle;
fn control_handle(&self) -> &DriverHostControllerControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverHostControllerRestartResponder {
pub fn send(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut status: i32) -> Result<(), fidl::Error> {
let _result = self.send_raw(status);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut status: i32) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DriverHostControllerRestartResponse>(
(status,),
self.tx_id,
0x1a870ec87b9fa33d,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SystemStateTransitionMarker;
impl fidl::endpoints::ProtocolMarker for SystemStateTransitionMarker {
type Proxy = SystemStateTransitionProxy;
type RequestStream = SystemStateTransitionRequestStream;
const DEBUG_NAME: &'static str = "fuchsia.device.manager.SystemStateTransition";
}
impl fidl::endpoints::DiscoverableProtocolMarker for SystemStateTransitionMarker {}
pub type SystemStateTransitionGetMexecZbisResult = Result<(fidl::Vmo, fidl::Vmo), i32>;
pub trait SystemStateTransitionProxyInterface: Send + Sync {
type GetTerminationSystemStateResponseFut: std::future::Future<Output = Result<SystemPowerState, fidl::Error>>
+ Send;
fn r#get_termination_system_state(&self) -> Self::GetTerminationSystemStateResponseFut;
type GetMexecZbisResponseFut: std::future::Future<Output = Result<SystemStateTransitionGetMexecZbisResult, fidl::Error>>
+ Send;
fn r#get_mexec_zbis(&self) -> Self::GetMexecZbisResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SystemStateTransitionSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl SystemStateTransitionSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<SystemStateTransitionMarker 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()
}
pub fn wait_for_event(
&self,
deadline: zx::Time,
) -> Result<SystemStateTransitionEvent, fidl::Error> {
SystemStateTransitionEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#get_termination_system_state(
&self,
___deadline: zx::Time,
) -> Result<SystemPowerState, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
SystemStateTransitionGetTerminationSystemStateResponse,
>(
(),
0x12161ad87afc0b63,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.state)
}
pub fn r#get_mexec_zbis(
&self,
___deadline: zx::Time,
) -> Result<SystemStateTransitionGetMexecZbisResult, fidl::Error> {
let _response =
self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
SystemStateTransitionGetMexecZbisResponse,
i32,
>>(
(),
0x1ca6dd89b84f94c7,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.map(|x| (x.kernel_zbi, x.data_zbi)))
}
}
#[derive(Debug, Clone)]
pub struct SystemStateTransitionProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for SystemStateTransitionProxy {
type Protocol = SystemStateTransitionMarker;
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 SystemStateTransitionProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<SystemStateTransitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> SystemStateTransitionEventStream {
SystemStateTransitionEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#get_termination_system_state(
&self,
) -> fidl::client::QueryResponseFut<SystemPowerState> {
SystemStateTransitionProxyInterface::r#get_termination_system_state(self)
}
pub fn r#get_mexec_zbis(
&self,
) -> fidl::client::QueryResponseFut<SystemStateTransitionGetMexecZbisResult> {
SystemStateTransitionProxyInterface::r#get_mexec_zbis(self)
}
}
impl SystemStateTransitionProxyInterface for SystemStateTransitionProxy {
type GetTerminationSystemStateResponseFut = fidl::client::QueryResponseFut<SystemPowerState>;
fn r#get_termination_system_state(&self) -> Self::GetTerminationSystemStateResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<SystemPowerState, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
SystemStateTransitionGetTerminationSystemStateResponse,
0x12161ad87afc0b63,
>(_buf?)?;
Ok(_response.state)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, SystemPowerState>(
(),
0x12161ad87afc0b63,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
type GetMexecZbisResponseFut =
fidl::client::QueryResponseFut<SystemStateTransitionGetMexecZbisResult>;
fn r#get_mexec_zbis(&self) -> Self::GetMexecZbisResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<SystemStateTransitionGetMexecZbisResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::ResultType<SystemStateTransitionGetMexecZbisResponse, i32>,
0x1ca6dd89b84f94c7,
>(_buf?)?;
Ok(_response.map(|x| (x.kernel_zbi, x.data_zbi)))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
SystemStateTransitionGetMexecZbisResult,
>(
(),
0x1ca6dd89b84f94c7,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct SystemStateTransitionEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for SystemStateTransitionEventStream {}
impl futures::stream::FusedStream for SystemStateTransitionEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for SystemStateTransitionEventStream {
type Item = Result<SystemStateTransitionEvent, 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(SystemStateTransitionEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum SystemStateTransitionEvent {}
impl SystemStateTransitionEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<SystemStateTransitionEvent, 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 {
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<SystemStateTransitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct SystemStateTransitionRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for SystemStateTransitionRequestStream {}
impl futures::stream::FusedStream for SystemStateTransitionRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for SystemStateTransitionRequestStream {
type Protocol = SystemStateTransitionMarker;
type ControlHandle = SystemStateTransitionControlHandle;
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 {
SystemStateTransitionControlHandle { inner: self.inner.clone() }
}
fn into_inner(self) -> (::std::sync::Arc<fidl::ServeInner>, bool) {
(self.inner, self.is_terminated)
}
fn from_inner(inner: std::sync::Arc<fidl::ServeInner>, is_terminated: bool) -> Self {
Self { inner, is_terminated }
}
}
impl futures::Stream for SystemStateTransitionRequestStream {
type Item = Result<SystemStateTransitionRequest, 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 SystemStateTransitionRequestStream after completion");
}
fidl::encoding::with_tls_decode_buf(|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))))
}
}
let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
std::task::Poll::Ready(Some(match header.ordinal {
0x12161ad87afc0b63 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
SystemStateTransitionControlHandle { inner: this.inner.clone() };
Ok(SystemStateTransitionRequest::GetTerminationSystemState {
responder: SystemStateTransitionGetTerminationSystemStateResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x1ca6dd89b84f94c7 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload);
fidl::encoding::Decoder::decode_into::<fidl::encoding::EmptyPayload>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
SystemStateTransitionControlHandle { inner: this.inner.clone() };
Ok(SystemStateTransitionRequest::GetMexecZbis {
responder: SystemStateTransitionGetMexecZbisResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<SystemStateTransitionMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum SystemStateTransitionRequest {
GetTerminationSystemState { responder: SystemStateTransitionGetTerminationSystemStateResponder },
GetMexecZbis { responder: SystemStateTransitionGetMexecZbisResponder },
}
impl SystemStateTransitionRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_get_termination_system_state(
self,
) -> Option<(SystemStateTransitionGetTerminationSystemStateResponder)> {
if let SystemStateTransitionRequest::GetTerminationSystemState { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_mexec_zbis(self) -> Option<(SystemStateTransitionGetMexecZbisResponder)> {
if let SystemStateTransitionRequest::GetMexecZbis { responder } = self {
Some((responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
SystemStateTransitionRequest::GetTerminationSystemState { .. } => {
"get_termination_system_state"
}
SystemStateTransitionRequest::GetMexecZbis { .. } => "get_mexec_zbis",
}
}
}
#[derive(Debug, Clone)]
pub struct SystemStateTransitionControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for SystemStateTransitionControlHandle {
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<'a>(&'a self) -> fidl::OnSignals<'a> {
self.inner.channel().on_closed()
}
}
impl SystemStateTransitionControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SystemStateTransitionGetTerminationSystemStateResponder {
control_handle: std::mem::ManuallyDrop<SystemStateTransitionControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for SystemStateTransitionGetTerminationSystemStateResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for SystemStateTransitionGetTerminationSystemStateResponder {
type ControlHandle = SystemStateTransitionControlHandle;
fn control_handle(&self) -> &SystemStateTransitionControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl SystemStateTransitionGetTerminationSystemStateResponder {
pub fn send(self, mut state: SystemPowerState) -> Result<(), fidl::Error> {
let _result = self.send_raw(state);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut state: SystemPowerState) -> Result<(), fidl::Error> {
let _result = self.send_raw(state);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut state: SystemPowerState) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<SystemStateTransitionGetTerminationSystemStateResponse>(
(state,),
self.tx_id,
0x12161ad87afc0b63,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SystemStateTransitionGetMexecZbisResponder {
control_handle: std::mem::ManuallyDrop<SystemStateTransitionControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for SystemStateTransitionGetMexecZbisResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for SystemStateTransitionGetMexecZbisResponder {
type ControlHandle = SystemStateTransitionControlHandle;
fn control_handle(&self) -> &SystemStateTransitionControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl SystemStateTransitionGetMexecZbisResponder {
pub fn send(self, mut result: Result<(fidl::Vmo, fidl::Vmo), i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut result: Result<(fidl::Vmo, fidl::Vmo), i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<(fidl::Vmo, fidl::Vmo), i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::ResultType<
SystemStateTransitionGetMexecZbisResponse,
i32,
>>(
result,
self.tx_id,
0x1ca6dd89b84f94c7,
fidl::encoding::DynamicFlags::empty(),
)
}
}
mod internal {
use super::*;
unsafe impl fidl::encoding::TypeMarker for AddDeviceConfig {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
}
impl fidl::encoding::ValueTypeMarker for AddDeviceConfig {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for AddDeviceConfig {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
if self.bits & Self::all().bits != self.bits {
return Err(fidl::Error::InvalidBitsValue);
}
encoder.write_num(self.bits, offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for AddDeviceConfig {
#[inline(always)]
fn new_empty() -> Self {
Self::empty()
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u32>(offset);
*self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for SystemPowerState {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
std::mem::align_of::<u8>()
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
std::mem::size_of::<u8>()
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
false
}
}
impl fidl::encoding::ValueTypeMarker for SystemPowerState {
type Borrowed<'a> = Self;
#[inline(always)]
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
*value
}
}
unsafe impl fidl::encoding::Encode<Self> for SystemPowerState {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<Self>(offset);
encoder.write_num(self.into_primitive(), offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for SystemPowerState {
#[inline(always)]
fn new_empty() -> Self {
Self::FullyOn
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let prim = decoder.read_num::<u8>(offset);
*self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for AddDeviceArgs {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
104
}
}
impl fidl::encoding::ValueTypeMarker for AddDeviceArgs {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<AddDeviceArgs> for &AddDeviceArgs {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<AddDeviceArgs>(offset);
fidl::encoding::Encode::<AddDeviceArgs>::encode(
(
<fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol_id),
<DevicePropertyList as fidl::encoding::ValueTypeMarker>::borrow(&self.property_list),
<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_path),
<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>> as fidl::encoding::ValueTypeMarker>::borrow(&self.args),
<AddDeviceConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.device_add_config),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_init),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.dfv2_device_symbol),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
T1: fidl::encoding::Encode<u32>,
T2: fidl::encoding::Encode<DevicePropertyList>,
T3: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>>,
T4: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>>,
T5: fidl::encoding::Encode<AddDeviceConfig>,
T6: fidl::encoding::Encode<bool>,
T7: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<AddDeviceArgs> for (T0, T1, T2, T3, T4, T5, T6, T7)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<AddDeviceArgs>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(88);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
self.2.encode(encoder, offset + 24, depth)?;
self.3.encode(encoder, offset + 56, depth)?;
self.4.encode(encoder, offset + 72, depth)?;
self.5.encode(encoder, offset + 88, depth)?;
self.6.encode(encoder, offset + 92, depth)?;
self.7.encode(encoder, offset + 96, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for AddDeviceArgs {
#[inline(always)]
fn new_empty() -> Self {
Self {
name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
protocol_id: fidl::new_empty!(u32),
property_list: fidl::new_empty!(DevicePropertyList),
driver_path: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>
),
args: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>
),
device_add_config: fidl::new_empty!(AddDeviceConfig),
has_init: fidl::new_empty!(bool),
dfv2_device_symbol: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffffff00000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 16
+ ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(88) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffff0000000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 88
+ ((0xffffff0000000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(
fidl::encoding::BoundedString<31>,
&mut self.name,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(u32, &mut self.protocol_id, decoder, offset + 16, _depth)?;
fidl::decode!(
DevicePropertyList,
&mut self.property_list,
decoder,
offset + 24,
_depth
)?;
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>,
&mut self.driver_path,
decoder,
offset + 56,
_depth
)?;
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>,
&mut self.args,
decoder,
offset + 72,
_depth
)?;
fidl::decode!(
AddDeviceConfig,
&mut self.device_add_config,
decoder,
offset + 88,
_depth
)?;
fidl::decode!(bool, &mut self.has_init, decoder, offset + 92, _depth)?;
fidl::decode!(u64, &mut self.dfv2_device_symbol, decoder, offset + 96, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for AdministratorUnregisterSystemStorageForShutdownResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for AdministratorUnregisterSystemStorageForShutdownResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<AdministratorUnregisterSystemStorageForShutdownResponse>
for &AdministratorUnregisterSystemStorageForShutdownResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<AdministratorUnregisterSystemStorageForShutdownResponse>(
offset,
);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut AdministratorUnregisterSystemStorageForShutdownResponse)
.write_unaligned(
(self as *const AdministratorUnregisterSystemStorageForShutdownResponse)
.read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<i32>>
fidl::encoding::Encode<AdministratorUnregisterSystemStorageForShutdownResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<AdministratorUnregisterSystemStorageForShutdownResponse>(
offset,
);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for AdministratorUnregisterSystemStorageForShutdownResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { status: fidl::new_empty!(i32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for BindInstruction {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
12
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for BindInstruction {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<BindInstruction> for &BindInstruction {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<BindInstruction>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut BindInstruction)
.write_unaligned((self as *const BindInstruction).read());
}
Ok(())
}
}
unsafe impl<
T0: fidl::encoding::Encode<u32>,
T1: fidl::encoding::Encode<u32>,
T2: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<BindInstruction> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<BindInstruction>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 4, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for BindInstruction {
#[inline(always)]
fn new_empty() -> Self {
Self {
op: fidl::new_empty!(u32),
arg: fidl::new_empty!(u32),
debug: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeDevice {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
32
}
}
impl fidl::encoding::ValueTypeMarker for CompositeDevice {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CompositeDevice> for &CompositeDevice {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeDevice>(offset);
fidl::encoding::Encode::<CompositeDevice>::encode(
(
<fidl::encoding::Vector<Fragment, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.fragments),
<fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<Fragment, 16>>,
T1: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
> fidl::encoding::Encode<CompositeDevice> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeDevice>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeDevice {
#[inline(always)]
fn new_empty() -> Self {
Self {
fragments: fidl::new_empty!(fidl::encoding::Vector<Fragment, 16>),
name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::Vector<Fragment, 16>, &mut self.fragments, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl::encoding::BoundedString<31>,
&mut self.name,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeDeviceDescriptor {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
72
}
}
impl fidl::encoding::ValueTypeMarker for CompositeDeviceDescriptor {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CompositeDeviceDescriptor> for &CompositeDeviceDescriptor {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeDeviceDescriptor>(offset);
fidl::encoding::Encode::<CompositeDeviceDescriptor>::encode(
(
<fidl::encoding::Vector<DeviceProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.props),
<fidl::encoding::Vector<DeviceStrProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.str_props),
<fidl::encoding::Vector<DeviceFragment, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.fragments),
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.primary_fragment_index),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.spawn_colocated),
<fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.metadata),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<DeviceProperty, 256>>,
T1: fidl::encoding::Encode<fidl::encoding::Vector<DeviceStrProperty, 256>>,
T2: fidl::encoding::Encode<fidl::encoding::Vector<DeviceFragment, 16>>,
T3: fidl::encoding::Encode<u32>,
T4: fidl::encoding::Encode<bool>,
T5: fidl::encoding::Encode<
fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
>,
> fidl::encoding::Encode<CompositeDeviceDescriptor> for (T0, T1, T2, T3, T4, T5)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeDeviceDescriptor>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
self.2.encode(encoder, offset + 32, depth)?;
self.3.encode(encoder, offset + 48, depth)?;
self.4.encode(encoder, offset + 52, depth)?;
self.5.encode(encoder, offset + 56, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeDeviceDescriptor {
#[inline(always)]
fn new_empty() -> Self {
Self {
props: fidl::new_empty!(fidl::encoding::Vector<DeviceProperty, 256>),
str_props: fidl::new_empty!(fidl::encoding::Vector<DeviceStrProperty, 256>),
fragments: fidl::new_empty!(fidl::encoding::Vector<DeviceFragment, 16>),
primary_fragment_index: fidl::new_empty!(u32),
spawn_colocated: fidl::new_empty!(bool),
metadata: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffff0000000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 48
+ ((0xffffff0000000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::Vector<DeviceProperty, 256>, &mut self.props, decoder, offset + 0, _depth)?;
fidl::decode!(fidl::encoding::Vector<DeviceStrProperty, 256>, &mut self.str_props, decoder, offset + 16, _depth)?;
fidl::decode!(fidl::encoding::Vector<DeviceFragment, 16>, &mut self.fragments, decoder, offset + 32, _depth)?;
fidl::decode!(u32, &mut self.primary_fragment_index, decoder, offset + 48, _depth)?;
fidl::decode!(bool, &mut self.spawn_colocated, decoder, offset + 52, _depth)?;
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
&mut self.metadata,
decoder,
offset + 56,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecDescriptor {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
32
}
}
impl fidl::encoding::ValueTypeMarker for CompositeNodeSpecDescriptor {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CompositeNodeSpecDescriptor> for &CompositeNodeSpecDescriptor {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeNodeSpecDescriptor>(offset);
fidl::encoding::Encode::<CompositeNodeSpecDescriptor>::encode(
(
<fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec> as fidl::encoding::ValueTypeMarker>::borrow(&self.parents),
<fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.metadata),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>,
>,
T1: fidl::encoding::Encode<
fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
>,
> fidl::encoding::Encode<CompositeNodeSpecDescriptor> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeNodeSpecDescriptor>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeNodeSpecDescriptor {
#[inline(always)]
fn new_empty() -> Self {
Self {
parents: fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>
),
metadata: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>,
&mut self.parents,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::Vector<DeviceMetadata, 32>>,
&mut self.metadata,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorAddCompositeDeviceRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
88
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorAddCompositeDeviceRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorAddCompositeDeviceRequest>
for &CoordinatorAddCompositeDeviceRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddCompositeDeviceRequest>(offset);
fidl::encoding::Encode::<CoordinatorAddCompositeDeviceRequest>::encode(
(
<fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(
&self.name,
),
<CompositeDeviceDescriptor as fidl::encoding::ValueTypeMarker>::borrow(
&self.comp_desc,
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
T1: fidl::encoding::Encode<CompositeDeviceDescriptor>,
> fidl::encoding::Encode<CoordinatorAddCompositeDeviceRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddCompositeDeviceRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorAddCompositeDeviceRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
comp_desc: fidl::new_empty!(CompositeDeviceDescriptor),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::BoundedString<31>,
&mut self.name,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
CompositeDeviceDescriptor,
&mut self.comp_desc,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorAddCompositeNodeSpecRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
48
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorAddCompositeNodeSpecRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorAddCompositeNodeSpecRequest>
for &CoordinatorAddCompositeNodeSpecRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddCompositeNodeSpecRequest>(offset);
fidl::encoding::Encode::<CoordinatorAddCompositeNodeSpecRequest>::encode(
(
<fidl::encoding::BoundedString<31> as fidl::encoding::ValueTypeMarker>::borrow(
&self.name,
),
<CompositeNodeSpecDescriptor as fidl::encoding::ValueTypeMarker>::borrow(
&self.spec,
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<31>>,
T1: fidl::encoding::Encode<CompositeNodeSpecDescriptor>,
> fidl::encoding::Encode<CoordinatorAddCompositeNodeSpecRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddCompositeNodeSpecRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorAddCompositeNodeSpecRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
name: fidl::new_empty!(fidl::encoding::BoundedString<31>),
spec: fidl::new_empty!(CompositeNodeSpecDescriptor),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::BoundedString<31>,
&mut self.name,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
CompositeNodeSpecDescriptor,
&mut self.spec,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorAddDeviceRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
120
}
}
impl fidl::encoding::ResourceTypeMarker for CoordinatorAddDeviceRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorAddDeviceRequest>
for &mut CoordinatorAddDeviceRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddDeviceRequest>(offset);
fidl::encoding::Encode::<CoordinatorAddDeviceRequest>::encode(
(
<AddDeviceArgs as fidl::encoding::ValueTypeMarker>::borrow(&self.args),
<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.coordinator),
<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.device_controller),
<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.inspect),
<fidl::encoding::Optional<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.outgoing_dir),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<AddDeviceArgs>,
T1: fidl::encoding::Encode<
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>>,
>,
T2: fidl::encoding::Encode<
fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>>,
>,
T3: fidl::encoding::Encode<
fidl::encoding::Optional<
fidl::encoding::HandleType<
fidl::Vmo,
{ fidl::ObjectType::VMO.into_raw() },
2147483648,
>,
>,
>,
T4: fidl::encoding::Encode<
fidl::encoding::Optional<
fidl::encoding::Endpoint<
fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
>,
>,
>,
> fidl::encoding::Encode<CoordinatorAddDeviceRequest> for (T0, T1, T2, T3, T4)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddDeviceRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 104, depth)?;
self.2.encode(encoder, offset + 108, depth)?;
self.3.encode(encoder, offset + 112, depth)?;
self.4.encode(encoder, offset + 116, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorAddDeviceRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
args: fidl::new_empty!(AddDeviceArgs),
coordinator: fidl::new_empty!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>>
),
device_controller: fidl::new_empty!(
fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>>
),
inspect: fidl::new_empty!(
fidl::encoding::Optional<
fidl::encoding::HandleType<
fidl::Vmo,
{ fidl::ObjectType::VMO.into_raw() },
2147483648,
>,
>
),
outgoing_dir: fidl::new_empty!(
fidl::encoding::Optional<
fidl::encoding::Endpoint<
fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
>,
>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(AddDeviceArgs, &mut self.args, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CoordinatorMarker>>,
&mut self.coordinator,
decoder,
offset + 104,
_depth
)?;
fidl::decode!(
fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DeviceControllerMarker>>,
&mut self.device_controller,
decoder,
offset + 108,
_depth
)?;
fidl::decode!(
fidl::encoding::Optional<
fidl::encoding::HandleType<
fidl::Vmo,
{ fidl::ObjectType::VMO.into_raw() },
2147483648,
>,
>,
&mut self.inspect,
decoder,
offset + 112,
_depth
)?;
fidl::decode!(
fidl::encoding::Optional<
fidl::encoding::Endpoint<
fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
>,
>,
&mut self.outgoing_dir,
decoder,
offset + 116,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorAddMetadataRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
24
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorAddMetadataRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorAddMetadataRequest>
for &CoordinatorAddMetadataRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddMetadataRequest>(offset);
fidl::encoding::Encode::<CoordinatorAddMetadataRequest>::encode(
(
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
<fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<u32>,
T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>>,
> fidl::encoding::Encode<CoordinatorAddMetadataRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddMetadataRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorAddMetadataRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
key: fidl::new_empty!(u32),
data: fidl::new_empty!(fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffffff00000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 0
+ ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(u32, &mut self.key, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::Vector<u8, 8192>>,
&mut self.data,
decoder,
offset + 8,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorBindDeviceRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorBindDeviceRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorBindDeviceRequest> for &CoordinatorBindDeviceRequest {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorBindDeviceRequest>(offset);
fidl::encoding::Encode::<CoordinatorBindDeviceRequest>::encode(
(
<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_url_suffix),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>>,
> fidl::encoding::Encode<CoordinatorBindDeviceRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorBindDeviceRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorBindDeviceRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
driver_url_suffix: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::BoundedString<1024>>,
&mut self.driver_url_suffix,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorConnectFidlProtocolRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
56
}
}
impl fidl::encoding::ResourceTypeMarker for CoordinatorConnectFidlProtocolRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorConnectFidlProtocolRequest>
for &mut CoordinatorConnectFidlProtocolRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorConnectFidlProtocolRequest>(offset);
fidl::encoding::Encode::<CoordinatorConnectFidlProtocolRequest>::encode(
(
<fidl::encoding::Optional<fidl::encoding::BoundedString<31>> as fidl::encoding::ValueTypeMarker>::borrow(&self.fragment_name),
<fidl::encoding::Optional<fidl::encoding::BoundedString<255>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_name),
<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol_name),
<fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.server),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<31>>>,
T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<255>>>,
T2: fidl::encoding::Encode<fidl::encoding::BoundedString<255>>,
T3: fidl::encoding::Encode<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>,
> fidl::encoding::Encode<CoordinatorConnectFidlProtocolRequest> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorConnectFidlProtocolRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
self.2.encode(encoder, offset + 32, depth)?;
self.3.encode(encoder, offset + 48, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorConnectFidlProtocolRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
fragment_name: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::BoundedString<31>>
),
service_name: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::BoundedString<255>>
),
protocol_name: fidl::new_empty!(fidl::encoding::BoundedString<255>),
server: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffffff00000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 48
+ ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::BoundedString<31>>,
&mut self.fragment_name,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::Optional<fidl::encoding::BoundedString<255>>,
&mut self.service_name,
decoder,
offset + 16,
_depth
)?;
fidl::decode!(
fidl::encoding::BoundedString<255>,
&mut self.protocol_name,
decoder,
offset + 32,
_depth
)?;
fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, &mut self.server, decoder, offset + 48, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorGetMetadataRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorGetMetadataRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorGetMetadataRequest>
for &CoordinatorGetMetadataRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut CoordinatorGetMetadataRequest)
.write_unaligned((self as *const CoordinatorGetMetadataRequest).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u32>>
fidl::encoding::Encode<CoordinatorGetMetadataRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorGetMetadataRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { key: fidl::new_empty!(u32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorGetMetadataSizeRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorGetMetadataSizeRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorGetMetadataSizeRequest>
for &CoordinatorGetMetadataSizeRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataSizeRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut CoordinatorGetMetadataSizeRequest)
.write_unaligned((self as *const CoordinatorGetMetadataSizeRequest).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u32>>
fidl::encoding::Encode<CoordinatorGetMetadataSizeRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataSizeRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorGetMetadataSizeRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { key: fidl::new_empty!(u32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorLoadFirmwareRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
32
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorLoadFirmwareRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorLoadFirmwareRequest>
for &CoordinatorLoadFirmwareRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorLoadFirmwareRequest>(offset);
fidl::encoding::Encode::<CoordinatorLoadFirmwareRequest>::encode(
(
<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_path),
<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.fw_path),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>,
T1: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>,
> fidl::encoding::Encode<CoordinatorLoadFirmwareRequest> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorLoadFirmwareRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorLoadFirmwareRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
driver_path: fidl::new_empty!(fidl::encoding::BoundedString<1024>),
fw_path: fidl::new_empty!(fidl::encoding::BoundedString<1024>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::BoundedString<1024>,
&mut self.driver_path,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::BoundedString<1024>,
&mut self.fw_path,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorScheduleRemoveRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
1
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorScheduleRemoveRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorScheduleRemoveRequest>
for &CoordinatorScheduleRemoveRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorScheduleRemoveRequest>(offset);
fidl::encoding::Encode::<CoordinatorScheduleRemoveRequest>::encode(
(<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.unbind_self),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<bool>>
fidl::encoding::Encode<CoordinatorScheduleRemoveRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorScheduleRemoveRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorScheduleRemoveRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { unbind_self: fidl::new_empty!(bool) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(bool, &mut self.unbind_self, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorAddDeviceResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorAddDeviceResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorAddDeviceResponse> for &CoordinatorAddDeviceResponse {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddDeviceResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut CoordinatorAddDeviceResponse)
.write_unaligned((self as *const CoordinatorAddDeviceResponse).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u64>>
fidl::encoding::Encode<CoordinatorAddDeviceResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorAddDeviceResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorAddDeviceResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { local_device_id: fidl::new_empty!(u64) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorGetMetadataSizeResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorGetMetadataSizeResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorGetMetadataSizeResponse>
for &CoordinatorGetMetadataSizeResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataSizeResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut CoordinatorGetMetadataSizeResponse)
.write_unaligned((self as *const CoordinatorGetMetadataSizeResponse).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u64>>
fidl::encoding::Encode<CoordinatorGetMetadataSizeResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataSizeResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorGetMetadataSizeResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { size: fidl::new_empty!(u64) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorGetMetadataResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorGetMetadataResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorGetMetadataResponse>
for &CoordinatorGetMetadataResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataResponse>(offset);
fidl::encoding::Encode::<CoordinatorGetMetadataResponse>::encode(
(<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
&self.data,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>>>
fidl::encoding::Encode<CoordinatorGetMetadataResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetMetadataResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorGetMetadataResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::Vector<u8, 8192>, &mut self.data, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorGetTopologicalPathResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorGetTopologicalPathResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorGetTopologicalPathResponse>
for &CoordinatorGetTopologicalPathResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetTopologicalPathResponse>(offset);
fidl::encoding::Encode::<CoordinatorGetTopologicalPathResponse>::encode(
(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(
&self.path,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>>
fidl::encoding::Encode<CoordinatorGetTopologicalPathResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorGetTopologicalPathResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorGetTopologicalPathResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { path: fidl::new_empty!(fidl::encoding::BoundedString<1024>) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::BoundedString<1024>,
&mut self.path,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorLoadFirmwareResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ResourceTypeMarker for CoordinatorLoadFirmwareResponse {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorLoadFirmwareResponse>
for &mut CoordinatorLoadFirmwareResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorLoadFirmwareResponse>(offset);
fidl::encoding::Encode::<CoordinatorLoadFirmwareResponse>::encode(
(
<fidl::encoding::HandleType<
fidl::Vmo,
{ fidl::ObjectType::VMO.into_raw() },
2147483648,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.vmo
),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.size),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::HandleType<
fidl::Vmo,
{ fidl::ObjectType::VMO.into_raw() },
2147483648,
>,
>,
T1: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<CoordinatorLoadFirmwareResponse> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorLoadFirmwareResponse>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorLoadFirmwareResponse {
#[inline(always)]
fn new_empty() -> Self {
Self {
vmo: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>),
size: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffffff00000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 0
+ ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, &mut self.vmo, decoder, offset + 0, _depth)?;
fidl::decode!(u64, &mut self.size, decoder, offset + 8, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CoordinatorScheduleUnbindChildrenResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
1
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
1
}
}
impl fidl::encoding::ValueTypeMarker for CoordinatorScheduleUnbindChildrenResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<CoordinatorScheduleUnbindChildrenResponse>
for &CoordinatorScheduleUnbindChildrenResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorScheduleUnbindChildrenResponse>(offset);
fidl::encoding::Encode::<CoordinatorScheduleUnbindChildrenResponse>::encode(
(<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.has_children),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<bool>>
fidl::encoding::Encode<CoordinatorScheduleUnbindChildrenResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CoordinatorScheduleUnbindChildrenResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CoordinatorScheduleUnbindChildrenResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { has_children: fidl::new_empty!(bool) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(bool, &mut self.has_children, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerBindDriverRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
40
}
}
impl fidl::encoding::ResourceTypeMarker for DeviceControllerBindDriverRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerBindDriverRequest>
for &mut DeviceControllerBindDriverRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerBindDriverRequest>(offset);
fidl::encoding::Encode::<DeviceControllerBindDriverRequest>::encode(
(
<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_path),
<fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.driver),
<fidl::encoding::BoundedString<2048> as fidl::encoding::ValueTypeMarker>::borrow(&self.default_dispatcher_scheduler_role),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>,
T1: fidl::encoding::Encode<
fidl::encoding::HandleType<
fidl::Vmo,
{ fidl::ObjectType::VMO.into_raw() },
2147483648,
>,
>,
T2: fidl::encoding::Encode<fidl::encoding::BoundedString<2048>>,
> fidl::encoding::Encode<DeviceControllerBindDriverRequest> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerBindDriverRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
self.2.encode(encoder, offset + 24, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerBindDriverRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
driver_path: fidl::new_empty!(fidl::encoding::BoundedString<1024>),
driver: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>),
default_dispatcher_scheduler_role: fidl::new_empty!(
fidl::encoding::BoundedString<2048>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffffff00000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 16
+ ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(
fidl::encoding::BoundedString<1024>,
&mut self.driver_path,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, &mut self.driver, decoder, offset + 16, _depth)?;
fidl::decode!(
fidl::encoding::BoundedString<2048>,
&mut self.default_dispatcher_scheduler_role,
decoder,
offset + 24,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerBindDriverResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
8
}
}
impl fidl::encoding::ResourceTypeMarker for DeviceControllerBindDriverResponse {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerBindDriverResponse>
for &mut DeviceControllerBindDriverResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerBindDriverResponse>(offset);
fidl::encoding::Encode::<DeviceControllerBindDriverResponse>::encode(
(
<i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
<fidl::encoding::Optional<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.test_output
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<i32>,
T1: fidl::encoding::Encode<
fidl::encoding::Optional<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>,
>,
> fidl::encoding::Encode<DeviceControllerBindDriverResponse> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerBindDriverResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 4, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerBindDriverResponse {
#[inline(always)]
fn new_empty() -> Self {
Self {
status: fidl::new_empty!(i32),
test_output: fidl::new_empty!(
fidl::encoding::Optional<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(i32, &mut self.status, decoder, offset + 0, _depth)?;
fidl::decode!(
fidl::encoding::Optional<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>,
&mut self.test_output,
decoder,
offset + 4,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerConnectMultiplexedRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
8
}
}
impl fidl::encoding::ResourceTypeMarker for DeviceControllerConnectMultiplexedRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerConnectMultiplexedRequest>
for &mut DeviceControllerConnectMultiplexedRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectMultiplexedRequest>(offset);
fidl::encoding::Encode::<DeviceControllerConnectMultiplexedRequest>::encode(
(
<fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.server
),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.include_node),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.include_controller),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>,
T1: fidl::encoding::Encode<bool>,
T2: fidl::encoding::Encode<bool>,
> fidl::encoding::Encode<DeviceControllerConnectMultiplexedRequest> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectMultiplexedRequest>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
(ptr as *mut u32).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 4, depth)?;
self.2.encode(encoder, offset + 5, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerConnectMultiplexedRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
server: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
include_node: fidl::new_empty!(bool),
include_controller: fidl::new_empty!(bool),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(4) };
let padval = unsafe { (ptr as *const u32).read_unaligned() };
let maskedval = padval & 0xffff0000u32;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 4
+ ((0xffff0000u32 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, &mut self.server, decoder, offset + 0, _depth)?;
fidl::decode!(bool, &mut self.include_node, decoder, offset + 4, _depth)?;
fidl::decode!(bool, &mut self.include_controller, decoder, offset + 5, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerConnectProxyRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
}
impl fidl::encoding::ResourceTypeMarker for DeviceControllerConnectProxyRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerConnectProxyRequest>
for &mut DeviceControllerConnectProxyRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectProxyRequest>(offset);
fidl::encoding::Encode::<DeviceControllerConnectProxyRequest>::encode(
(<fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.shadow
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>,
> fidl::encoding::Encode<DeviceControllerConnectProxyRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectProxyRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerConnectProxyRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
shadow: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, &mut self.shadow, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerConnectToControllerRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
}
impl fidl::encoding::ResourceTypeMarker for DeviceControllerConnectToControllerRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerConnectToControllerRequest>
for &mut DeviceControllerConnectToControllerRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectToControllerRequest>(offset);
fidl::encoding::Encode::<DeviceControllerConnectToControllerRequest>::encode(
(<fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.controller
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
>,
>,
> fidl::encoding::Encode<DeviceControllerConnectToControllerRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectToControllerRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerConnectToControllerRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
controller: fidl::new_empty!(
fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
>
),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<fidl_fuchsia_device::ControllerMarker>,
>,
&mut self.controller,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerConnectToDeviceProtocolRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
}
impl fidl::encoding::ResourceTypeMarker for DeviceControllerConnectToDeviceProtocolRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerConnectToDeviceProtocolRequest>
for &mut DeviceControllerConnectToDeviceProtocolRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectToDeviceProtocolRequest>(offset);
fidl::encoding::Encode::<DeviceControllerConnectToDeviceProtocolRequest>::encode(
(<fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.server
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::HandleType<
fidl::Channel,
{ fidl::ObjectType::CHANNEL.into_raw() },
2147483648,
>,
>,
> fidl::encoding::Encode<DeviceControllerConnectToDeviceProtocolRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerConnectToDeviceProtocolRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerConnectToDeviceProtocolRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
server: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, &mut self.server, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerInitResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for DeviceControllerInitResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerInitResponse> for &DeviceControllerInitResponse {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerInitResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DeviceControllerInitResponse)
.write_unaligned((self as *const DeviceControllerInitResponse).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<i32>>
fidl::encoding::Encode<DeviceControllerInitResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerInitResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerInitResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { status: fidl::new_empty!(i32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerResumeRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for DeviceControllerResumeRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerResumeRequest>
for &DeviceControllerResumeRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerResumeRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DeviceControllerResumeRequest)
.write_unaligned((self as *const DeviceControllerResumeRequest).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u32>>
fidl::encoding::Encode<DeviceControllerResumeRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerResumeRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerResumeRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { target_system_state: fidl::new_empty!(u32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerResumeResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for DeviceControllerResumeResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerResumeResponse>
for &DeviceControllerResumeResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerResumeResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DeviceControllerResumeResponse)
.write_unaligned((self as *const DeviceControllerResumeResponse).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<i32>>
fidl::encoding::Encode<DeviceControllerResumeResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerResumeResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerResumeResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { status: fidl::new_empty!(i32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerSuspendRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for DeviceControllerSuspendRequest {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerSuspendRequest>
for &DeviceControllerSuspendRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerSuspendRequest>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DeviceControllerSuspendRequest)
.write_unaligned((self as *const DeviceControllerSuspendRequest).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u32>>
fidl::encoding::Encode<DeviceControllerSuspendRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerSuspendRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerSuspendRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { flags: fidl::new_empty!(u32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceControllerSuspendResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for DeviceControllerSuspendResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceControllerSuspendResponse>
for &DeviceControllerSuspendResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerSuspendResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DeviceControllerSuspendResponse)
.write_unaligned((self as *const DeviceControllerSuspendResponse).read());
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<i32>>
fidl::encoding::Encode<DeviceControllerSuspendResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceControllerSuspendResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceControllerSuspendResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { status: fidl::new_empty!(i32) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceFragment {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
32
}
}
impl fidl::encoding::ValueTypeMarker for DeviceFragment {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceFragment> for &DeviceFragment {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceFragment>(offset);
fidl::encoding::Encode::<DeviceFragment>::encode(
(
<fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
<fidl::encoding::Vector<DeviceFragmentPart, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.parts),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<32>>,
T1: fidl::encoding::Encode<fidl::encoding::Vector<DeviceFragmentPart, 16>>,
> fidl::encoding::Encode<DeviceFragment> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceFragment>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceFragment {
#[inline(always)]
fn new_empty() -> Self {
Self {
name: fidl::new_empty!(fidl::encoding::BoundedString<32>),
parts: fidl::new_empty!(fidl::encoding::Vector<DeviceFragmentPart, 16>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::BoundedString<32>,
&mut self.name,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(fidl::encoding::Vector<DeviceFragmentPart, 16>, &mut self.parts, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceFragmentPart {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
16
}
}
impl fidl::encoding::ValueTypeMarker for DeviceFragmentPart {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceFragmentPart> for &DeviceFragmentPart {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceFragmentPart>(offset);
fidl::encoding::Encode::<DeviceFragmentPart>::encode(
(
<fidl::encoding::Vector<BindInstruction, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.match_program),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::Vector<BindInstruction, 32>>>
fidl::encoding::Encode<DeviceFragmentPart> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceFragmentPart>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceFragmentPart {
#[inline(always)]
fn new_empty() -> Self {
Self { match_program: fidl::new_empty!(fidl::encoding::Vector<BindInstruction, 32>) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::Vector<BindInstruction, 32>, &mut self.match_program, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceMetadata {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
24
}
}
impl fidl::encoding::ValueTypeMarker for DeviceMetadata {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceMetadata> for &DeviceMetadata {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceMetadata>(offset);
fidl::encoding::Encode::<DeviceMetadata>::encode(
(
<u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
&self.data,
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<u32>,
T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>>,
> fidl::encoding::Encode<DeviceMetadata> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceMetadata>(offset);
unsafe {
let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
(ptr as *mut u64).write_unaligned(0);
}
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 8, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceMetadata {
#[inline(always)]
fn new_empty() -> Self {
Self {
key: fidl::new_empty!(u32),
data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffffff00000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 0
+ ((0xffffffff00000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(u32, &mut self.key, decoder, offset + 0, _depth)?;
fidl::decode!(fidl::encoding::Vector<u8, 8192>, &mut self.data, decoder, offset + 8, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceProperty {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for DeviceProperty {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceProperty> for &DeviceProperty {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceProperty>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DeviceProperty)
.write_unaligned((self as *const DeviceProperty).read());
}
Ok(())
}
}
unsafe impl<
T0: fidl::encoding::Encode<u16>,
T1: fidl::encoding::Encode<u16>,
T2: fidl::encoding::Encode<u32>,
> fidl::encoding::Encode<DeviceProperty> for (T0, T1, T2)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceProperty>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 2, depth)?;
self.2.encode(encoder, offset + 4, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceProperty {
#[inline(always)]
fn new_empty() -> Self {
Self {
id: fidl::new_empty!(u16),
reserved: fidl::new_empty!(u16),
value: fidl::new_empty!(u32),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
unsafe {
std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
}
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DevicePropertyList {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
32
}
}
impl fidl::encoding::ValueTypeMarker for DevicePropertyList {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DevicePropertyList> for &DevicePropertyList {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DevicePropertyList>(offset);
fidl::encoding::Encode::<DevicePropertyList>::encode(
(
<fidl::encoding::Vector<DeviceProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.props),
<fidl::encoding::Vector<DeviceStrProperty, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.str_props),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Vector<DeviceProperty, 256>>,
T1: fidl::encoding::Encode<fidl::encoding::Vector<DeviceStrProperty, 256>>,
> fidl::encoding::Encode<DevicePropertyList> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DevicePropertyList>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DevicePropertyList {
#[inline(always)]
fn new_empty() -> Self {
Self {
props: fidl::new_empty!(fidl::encoding::Vector<DeviceProperty, 256>),
str_props: fidl::new_empty!(fidl::encoding::Vector<DeviceStrProperty, 256>),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(fidl::encoding::Vector<DeviceProperty, 256>, &mut self.props, decoder, offset + 0, _depth)?;
fidl::decode!(fidl::encoding::Vector<DeviceStrProperty, 256>, &mut self.str_props, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceStrProperty {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
32
}
}
impl fidl::encoding::ValueTypeMarker for DeviceStrProperty {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DeviceStrProperty> for &DeviceStrProperty {
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceStrProperty>(offset);
fidl::encoding::Encode::<DeviceStrProperty>::encode(
(
<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
&self.key,
),
<PropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>>,
T1: fidl::encoding::Encode<PropertyValue>,
> fidl::encoding::Encode<DeviceStrProperty> for (T0, T1)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceStrProperty>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 16, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceStrProperty {
#[inline(always)]
fn new_empty() -> Self {
Self {
key: fidl::new_empty!(fidl::encoding::BoundedString<255>),
value: fidl::new_empty!(PropertyValue),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::BoundedString<255>,
&mut self.key,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(PropertyValue, &mut self.value, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverHostControllerCreateDeviceRequest {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
8
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
32
}
}
impl fidl::encoding::ResourceTypeMarker for DriverHostControllerCreateDeviceRequest {
type Borrowed<'a> = &'a mut Self;
fn take_or_borrow<'a>(
value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DriverHostControllerCreateDeviceRequest>
for &mut DriverHostControllerCreateDeviceRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverHostControllerCreateDeviceRequest>(offset);
fidl::encoding::Encode::<DriverHostControllerCreateDeviceRequest>::encode(
(
<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.coordinator),
<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.device_controller),
<DeviceType as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.type_),
<u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.local_device_id),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>>,
>,
T1: fidl::encoding::Encode<
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>>,
>,
T2: fidl::encoding::Encode<DeviceType>,
T3: fidl::encoding::Encode<u64>,
> fidl::encoding::Encode<DriverHostControllerCreateDeviceRequest> for (T0, T1, T2, T3)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverHostControllerCreateDeviceRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
self.1.encode(encoder, offset + 4, depth)?;
self.2.encode(encoder, offset + 8, depth)?;
self.3.encode(encoder, offset + 24, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverHostControllerCreateDeviceRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
coordinator: fidl::new_empty!(
fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>>
),
device_controller: fidl::new_empty!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>>
),
type_: fidl::new_empty!(DeviceType),
local_device_id: fidl::new_empty!(u64),
}
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<CoordinatorMarker>>,
&mut self.coordinator,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceControllerMarker>>,
&mut self.device_controller,
decoder,
offset + 4,
_depth
)?;
fidl::decode!(DeviceType, &mut self.type_, decoder, offset + 8, _depth)?;
fidl::decode!(u64, &mut self.local_device_id, decoder, offset + 24, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverHostControllerCreateDeviceResponse {
type Owned = Self;
#[inline(always)]
fn inline_align(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn inline_size(_context: fidl::encoding::Context) -> usize {
4
}
#[inline(always)]
fn encode_is_copy() -> bool {
true
}
#[inline(always)]
fn decode_is_copy() -> bool {
true
}
}
impl fidl::encoding::ValueTypeMarker for DriverHostControllerCreateDeviceResponse {
type Borrowed<'a> = &'a Self;
fn borrow<'a>(
value: &'a <Self as fidl::encoding::TypeMarker>::Owned,
) -> Self::Borrowed<'a> {
value
}
}
unsafe impl fidl::encoding::Encode<DriverHostControllerCreateDeviceResponse>
for &DriverHostControllerCreateDeviceResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverHostControllerCreateDeviceResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DriverHostControllerCreateDeviceResponse).write_unaligned(
(self as *const DriverHostControllerCreateDeviceResponse).read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<i32>>
fidl::e