#![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 BINDING_RESULT_MAX: u8 = 10;
bitflags! {
#[derive(Default)]
pub struct DeviceFlags: u32 {
const IMMORTAL = 1;
const MUST_ISOLATE = 2;
const BOUND = 8;
const DEAD = 16;
const ALLOW_MULTI_COMPOSITE = 32;
const PROXY = 64;
const INVISIBLE = 128;
const SKIP_AUTOBIND = 256;
}
}
impl DeviceFlags {
#[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
}
}
bitflags! {
#[derive(Default)]
pub struct RematchFlags: u32 {
const REQUESTED = 1;
const NON_REQUESTED = 2;
const LEGACY_COMPOSITE = 4;
const COMPOSITE_SPEC = 8;
}
}
impl RematchFlags {
#[inline(always)]
pub fn from_bits_allow_unknown(bits: u32) -> Self {
unsafe { Self::from_bits_unchecked(bits) }
}
#[inline(always)]
pub fn has_unknown_bits(&self) -> bool {
self.get_unknown_bits() != 0
}
#[inline(always)]
pub fn get_unknown_bits(&self) -> u32 {
self.bits & !Self::all().bits
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct CompositeInfoIteratorGetNextResponse {
pub composites: Vec<CompositeInfo>,
}
impl fidl::Persistable for CompositeInfoIteratorGetNextResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct CompositeNodeSpecIteratorGetNextResponse {
pub specs: Vec<CompositeNodeSpecInfo>,
}
impl fidl::Persistable for CompositeNodeSpecIteratorGetNextResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct DeviceInfoIteratorGetNextResponse {
pub drivers: Vec<DeviceInfo>,
}
impl fidl::Persistable for DeviceInfoIteratorGetNextResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct DriverDevelopmentAddTestNodeRequest {
pub args: TestNodeAddArgs,
}
impl fidl::Persistable for DriverDevelopmentAddTestNodeRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverDevelopmentGetCompositeInfoRequest {
pub iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
}
impl fidl::Standalone for DriverDevelopmentGetCompositeInfoRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverDevelopmentGetDeviceInfoRequest {
pub device_filter: Vec<String>,
pub iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
pub exact_match: bool,
}
impl fidl::Standalone for DriverDevelopmentGetDeviceInfoRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverDevelopmentRemoveTestNodeRequest {
pub name: String,
}
impl fidl::Persistable for DriverDevelopmentRemoveTestNodeRequest {}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverDevelopmentRestartDriverHostsRequest {
pub driver_path: String,
pub rematch_flags: RematchFlags,
}
impl fidl::Persistable for DriverDevelopmentRestartDriverHostsRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct DriverDevelopmentBindAllUnboundNodesResponse {
pub binding_result: Vec<NodeBindingInfo>,
}
impl fidl::Persistable for DriverDevelopmentBindAllUnboundNodesResponse {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverDevelopmentIsDfv2Response {
pub response: bool,
}
impl fidl::Persistable for DriverDevelopmentIsDfv2Response {}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DriverDevelopmentRestartDriverHostsResponse {
pub count: u32,
}
impl fidl::Persistable for DriverDevelopmentRestartDriverHostsResponse {}
#[derive(Clone, Debug, PartialEq)]
pub struct DriverIndexDisableMatchWithDriverUrlRequest {
pub driver_url: fidl_fuchsia_pkg::PackageUrl,
}
impl fidl::Persistable for DriverIndexDisableMatchWithDriverUrlRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverIndexGetCompositeNodeSpecsRequest {
pub name_filter: Option<String>,
pub iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
}
impl fidl::Standalone for DriverIndexGetCompositeNodeSpecsRequest {}
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DriverIndexGetDriverInfoRequest {
pub driver_filter: Vec<String>,
pub iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
}
impl fidl::Standalone for DriverIndexGetDriverInfoRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct DriverIndexReEnableMatchWithDriverUrlRequest {
pub driver_url: fidl_fuchsia_pkg::PackageUrl,
}
impl fidl::Persistable for DriverIndexReEnableMatchWithDriverUrlRequest {}
#[derive(Clone, Debug, PartialEq)]
pub struct DriverInfoIteratorGetNextResponse {
pub drivers: Vec<DriverInfo>,
}
impl fidl::Persistable for DriverInfoIteratorGetNextResponse {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CompositeInfo {
pub name: Option<String>,
pub driver: Option<String>,
pub topological_path: Option<String>,
pub primary_index: Option<u32>,
pub node_info: Option<CompositeNodeInfo>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for CompositeInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CompositeNodeSpecInfo {
pub name: Option<String>,
pub driver: Option<String>,
pub primary_index: Option<u32>,
pub parent_names: Option<Vec<String>>,
pub parents: Option<Vec<fidl_fuchsia_driver_framework::ParentSpec>>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for CompositeNodeSpecInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CompositeParentNodeInfo {
pub name: Option<String>,
pub device: Option<String>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for CompositeParentNodeInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeviceInfo {
pub id: Option<u64>,
pub parent_ids: Option<Vec<u64>>,
pub child_ids: Option<Vec<u64>>,
pub driver_host_koid: Option<u64>,
pub topological_path: Option<String>,
pub bound_driver_libname: Option<String>,
pub bound_driver_url: Option<String>,
pub property_list: Option<fidl_fuchsia_device_manager::DevicePropertyList>,
pub flags: Option<DeviceFlags>,
pub moniker: Option<String>,
pub node_property_list: Option<Vec<fidl_fuchsia_driver_framework::NodeProperty>>,
pub offer_list: Option<Vec<fidl_fuchsia_component_decl::Offer>>,
pub protocol_id: Option<u32>,
pub protocol_name: Option<String>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for DeviceInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DriverInfo {
pub libname: Option<String>,
pub name: Option<String>,
pub url: Option<String>,
pub bind_rules: Option<BindRulesBytecode>,
pub package_type: Option<fidl_fuchsia_driver_index::DriverPackageType>,
pub package_hash: Option<fidl_fuchsia_pkg::BlobId>,
pub device_categories: Option<Vec<fidl_fuchsia_driver_index::DeviceCategory>>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for DriverInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct LegacyCompositeFragmentInfo {
pub name: Option<String>,
pub bind_rules: Option<Vec<fidl_fuchsia_device_manager::BindInstruction>>,
pub device: Option<String>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for LegacyCompositeFragmentInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct LegacyCompositeNodeInfo {
pub fragments: Option<Vec<LegacyCompositeFragmentInfo>>,
pub properties: Option<Vec<fidl_fuchsia_driver_framework::NodeProperty>>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for LegacyCompositeNodeInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct NodeBindingInfo {
pub node_name: Option<String>,
pub driver_url: Option<String>,
pub composite_specs: Option<Vec<fidl_fuchsia_driver_index::MatchedCompositeNodeSpecInfo>>,
pub legacy_composites: Option<Vec<CompositeInfo>>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for NodeBindingInfo {}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TestNodeAddArgs {
pub name: Option<String>,
pub properties: Option<Vec<fidl_fuchsia_driver_framework::NodeProperty>>,
#[deprecated = "Use `..Default::default()` to construct and `..` to match."]
#[doc(hidden)]
pub __non_exhaustive: (),
}
impl fidl::Persistable for TestNodeAddArgs {}
#[derive(Clone, Debug, PartialEq)]
pub enum BindRulesBytecode {
BytecodeV1(Vec<fidl_fuchsia_device_manager::BindInstruction>),
BytecodeV2(Vec<u8>),
}
impl BindRulesBytecode {
#[inline]
pub fn ordinal(&self) -> u64 {
match *self {
Self::BytecodeV1(_) => 1,
Self::BytecodeV2(_) => 2,
}
}
#[deprecated = "Strict unions should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
impl fidl::Persistable for BindRulesBytecode {}
#[derive(Clone, Debug, PartialEq)]
pub enum CompositeNodeInfo {
Legacy(LegacyCompositeNodeInfo),
Parents(Vec<CompositeParentNodeInfo>),
}
impl CompositeNodeInfo {
#[inline]
pub fn ordinal(&self) -> u64 {
match *self {
Self::Legacy(_) => 1,
Self::Parents(_) => 2,
}
}
#[deprecated = "Strict unions should not use `is_unknown`"]
#[inline]
pub fn is_unknown(&self) -> bool {
false
}
}
impl fidl::Persistable for CompositeNodeInfo {}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct CompositeInfoIteratorMarker;
impl fidl::endpoints::ProtocolMarker for CompositeInfoIteratorMarker {
type Proxy = CompositeInfoIteratorProxy;
type RequestStream = CompositeInfoIteratorRequestStream;
const DEBUG_NAME: &'static str = "(anonymous) CompositeInfoIterator";
}
pub trait CompositeInfoIteratorProxyInterface: Send + Sync {
type GetNextResponseFut: std::future::Future<Output = Result<Vec<CompositeInfo>, fidl::Error>>
+ Send;
fn r#get_next(&self) -> Self::GetNextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CompositeInfoIteratorSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl CompositeInfoIteratorSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<CompositeInfoIteratorMarker 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<CompositeInfoIteratorEvent, fidl::Error> {
CompositeInfoIteratorEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#get_next(&self, ___deadline: zx::Time) -> Result<Vec<CompositeInfo>, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, CompositeInfoIteratorGetNextResponse>(
(),
0x50af808a6e34bb96,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.composites)
}
}
#[derive(Debug, Clone)]
pub struct CompositeInfoIteratorProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for CompositeInfoIteratorProxy {
type Protocol = CompositeInfoIteratorMarker;
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 CompositeInfoIteratorProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<CompositeInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> CompositeInfoIteratorEventStream {
CompositeInfoIteratorEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<CompositeInfo>> {
CompositeInfoIteratorProxyInterface::r#get_next(self)
}
}
impl CompositeInfoIteratorProxyInterface for CompositeInfoIteratorProxy {
type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<CompositeInfo>>;
fn r#get_next(&self) -> Self::GetNextResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<Vec<CompositeInfo>, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
CompositeInfoIteratorGetNextResponse,
0x50af808a6e34bb96,
>(_buf?)?;
Ok(_response.composites)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<CompositeInfo>>(
(),
0x50af808a6e34bb96,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct CompositeInfoIteratorEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for CompositeInfoIteratorEventStream {}
impl futures::stream::FusedStream for CompositeInfoIteratorEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for CompositeInfoIteratorEventStream {
type Item = Result<CompositeInfoIteratorEvent, 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(CompositeInfoIteratorEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum CompositeInfoIteratorEvent {}
impl CompositeInfoIteratorEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<CompositeInfoIteratorEvent, 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:
<CompositeInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct CompositeInfoIteratorRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for CompositeInfoIteratorRequestStream {}
impl futures::stream::FusedStream for CompositeInfoIteratorRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for CompositeInfoIteratorRequestStream {
type Protocol = CompositeInfoIteratorMarker;
type ControlHandle = CompositeInfoIteratorControlHandle;
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 {
CompositeInfoIteratorControlHandle { 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 CompositeInfoIteratorRequestStream {
type Item = Result<CompositeInfoIteratorRequest, 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 CompositeInfoIteratorRequestStream 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 {
0x50af808a6e34bb96 => {
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 =
CompositeInfoIteratorControlHandle { inner: this.inner.clone() };
Ok(CompositeInfoIteratorRequest::GetNext {
responder: CompositeInfoIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<CompositeInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum CompositeInfoIteratorRequest {
GetNext { responder: CompositeInfoIteratorGetNextResponder },
}
impl CompositeInfoIteratorRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_get_next(self) -> Option<(CompositeInfoIteratorGetNextResponder)> {
if let CompositeInfoIteratorRequest::GetNext { responder } = self {
Some((responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
CompositeInfoIteratorRequest::GetNext { .. } => "get_next",
}
}
}
#[derive(Debug, Clone)]
pub struct CompositeInfoIteratorControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for CompositeInfoIteratorControlHandle {
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 CompositeInfoIteratorControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CompositeInfoIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop<CompositeInfoIteratorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CompositeInfoIteratorGetNextResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CompositeInfoIteratorGetNextResponder {
type ControlHandle = CompositeInfoIteratorControlHandle;
fn control_handle(&self) -> &CompositeInfoIteratorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CompositeInfoIteratorGetNextResponder {
pub fn send(self, mut composites: &[CompositeInfo]) -> Result<(), fidl::Error> {
let _result = self.send_raw(composites);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut composites: &[CompositeInfo],
) -> Result<(), fidl::Error> {
let _result = self.send_raw(composites);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut composites: &[CompositeInfo]) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<CompositeInfoIteratorGetNextResponse>(
(composites,),
self.tx_id,
0x50af808a6e34bb96,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct CompositeNodeSpecIteratorMarker;
impl fidl::endpoints::ProtocolMarker for CompositeNodeSpecIteratorMarker {
type Proxy = CompositeNodeSpecIteratorProxy;
type RequestStream = CompositeNodeSpecIteratorRequestStream;
const DEBUG_NAME: &'static str = "(anonymous) CompositeNodeSpecIterator";
}
pub trait CompositeNodeSpecIteratorProxyInterface: Send + Sync {
type GetNextResponseFut: std::future::Future<Output = Result<Vec<CompositeNodeSpecInfo>, fidl::Error>>
+ Send;
fn r#get_next(&self) -> Self::GetNextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CompositeNodeSpecIteratorSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl CompositeNodeSpecIteratorSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<CompositeNodeSpecIteratorMarker 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<CompositeNodeSpecIteratorEvent, fidl::Error> {
CompositeNodeSpecIteratorEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#get_next(
&self,
___deadline: zx::Time,
) -> Result<Vec<CompositeNodeSpecInfo>, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, CompositeNodeSpecIteratorGetNextResponse>(
(),
0x32fd110355479f71,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.specs)
}
}
#[derive(Debug, Clone)]
pub struct CompositeNodeSpecIteratorProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for CompositeNodeSpecIteratorProxy {
type Protocol = CompositeNodeSpecIteratorMarker;
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 CompositeNodeSpecIteratorProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<CompositeNodeSpecIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> CompositeNodeSpecIteratorEventStream {
CompositeNodeSpecIteratorEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<CompositeNodeSpecInfo>> {
CompositeNodeSpecIteratorProxyInterface::r#get_next(self)
}
}
impl CompositeNodeSpecIteratorProxyInterface for CompositeNodeSpecIteratorProxy {
type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<CompositeNodeSpecInfo>>;
fn r#get_next(&self) -> Self::GetNextResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<Vec<CompositeNodeSpecInfo>, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
CompositeNodeSpecIteratorGetNextResponse,
0x32fd110355479f71,
>(_buf?)?;
Ok(_response.specs)
}
self.client
.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<CompositeNodeSpecInfo>>(
(),
0x32fd110355479f71,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct CompositeNodeSpecIteratorEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for CompositeNodeSpecIteratorEventStream {}
impl futures::stream::FusedStream for CompositeNodeSpecIteratorEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for CompositeNodeSpecIteratorEventStream {
type Item = Result<CompositeNodeSpecIteratorEvent, 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(CompositeNodeSpecIteratorEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum CompositeNodeSpecIteratorEvent {}
impl CompositeNodeSpecIteratorEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<CompositeNodeSpecIteratorEvent, 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:
<CompositeNodeSpecIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct CompositeNodeSpecIteratorRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for CompositeNodeSpecIteratorRequestStream {}
impl futures::stream::FusedStream for CompositeNodeSpecIteratorRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for CompositeNodeSpecIteratorRequestStream {
type Protocol = CompositeNodeSpecIteratorMarker;
type ControlHandle = CompositeNodeSpecIteratorControlHandle;
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 {
CompositeNodeSpecIteratorControlHandle { 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 CompositeNodeSpecIteratorRequestStream {
type Item = Result<CompositeNodeSpecIteratorRequest, 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 CompositeNodeSpecIteratorRequestStream 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 {
0x32fd110355479f71 => {
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 = CompositeNodeSpecIteratorControlHandle {
inner: this.inner.clone(),
};
Ok(CompositeNodeSpecIteratorRequest::GetNext {
responder: CompositeNodeSpecIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name: <CompositeNodeSpecIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum CompositeNodeSpecIteratorRequest {
GetNext { responder: CompositeNodeSpecIteratorGetNextResponder },
}
impl CompositeNodeSpecIteratorRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_get_next(self) -> Option<(CompositeNodeSpecIteratorGetNextResponder)> {
if let CompositeNodeSpecIteratorRequest::GetNext { responder } = self {
Some((responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
CompositeNodeSpecIteratorRequest::GetNext { .. } => "get_next",
}
}
}
#[derive(Debug, Clone)]
pub struct CompositeNodeSpecIteratorControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for CompositeNodeSpecIteratorControlHandle {
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 CompositeNodeSpecIteratorControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CompositeNodeSpecIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop<CompositeNodeSpecIteratorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for CompositeNodeSpecIteratorGetNextResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for CompositeNodeSpecIteratorGetNextResponder {
type ControlHandle = CompositeNodeSpecIteratorControlHandle;
fn control_handle(&self) -> &CompositeNodeSpecIteratorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl CompositeNodeSpecIteratorGetNextResponder {
pub fn send(self, mut specs: &[CompositeNodeSpecInfo]) -> Result<(), fidl::Error> {
let _result = self.send_raw(specs);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(
self,
mut specs: &[CompositeNodeSpecInfo],
) -> Result<(), fidl::Error> {
let _result = self.send_raw(specs);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut specs: &[CompositeNodeSpecInfo]) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<CompositeNodeSpecIteratorGetNextResponse>(
(specs,),
self.tx_id,
0x32fd110355479f71,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DeviceInfoIteratorMarker;
impl fidl::endpoints::ProtocolMarker for DeviceInfoIteratorMarker {
type Proxy = DeviceInfoIteratorProxy;
type RequestStream = DeviceInfoIteratorRequestStream;
const DEBUG_NAME: &'static str = "(anonymous) DeviceInfoIterator";
}
pub trait DeviceInfoIteratorProxyInterface: Send + Sync {
type GetNextResponseFut: std::future::Future<Output = Result<Vec<DeviceInfo>, fidl::Error>>
+ Send;
fn r#get_next(&self) -> Self::GetNextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DeviceInfoIteratorSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl DeviceInfoIteratorSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<DeviceInfoIteratorMarker 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<DeviceInfoIteratorEvent, fidl::Error> {
DeviceInfoIteratorEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#get_next(&self, ___deadline: zx::Time) -> Result<Vec<DeviceInfo>, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, DeviceInfoIteratorGetNextResponse>(
(),
0x3e24784022ec70f7,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.drivers)
}
}
#[derive(Debug, Clone)]
pub struct DeviceInfoIteratorProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for DeviceInfoIteratorProxy {
type Protocol = DeviceInfoIteratorMarker;
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 DeviceInfoIteratorProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<DeviceInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> DeviceInfoIteratorEventStream {
DeviceInfoIteratorEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<DeviceInfo>> {
DeviceInfoIteratorProxyInterface::r#get_next(self)
}
}
impl DeviceInfoIteratorProxyInterface for DeviceInfoIteratorProxy {
type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<DeviceInfo>>;
fn r#get_next(&self) -> Self::GetNextResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<Vec<DeviceInfo>, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DeviceInfoIteratorGetNextResponse,
0x3e24784022ec70f7,
>(_buf?)?;
Ok(_response.drivers)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<DeviceInfo>>(
(),
0x3e24784022ec70f7,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct DeviceInfoIteratorEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for DeviceInfoIteratorEventStream {}
impl futures::stream::FusedStream for DeviceInfoIteratorEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for DeviceInfoIteratorEventStream {
type Item = Result<DeviceInfoIteratorEvent, 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(DeviceInfoIteratorEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum DeviceInfoIteratorEvent {}
impl DeviceInfoIteratorEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<DeviceInfoIteratorEvent, 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:
<DeviceInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct DeviceInfoIteratorRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for DeviceInfoIteratorRequestStream {}
impl futures::stream::FusedStream for DeviceInfoIteratorRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for DeviceInfoIteratorRequestStream {
type Protocol = DeviceInfoIteratorMarker;
type ControlHandle = DeviceInfoIteratorControlHandle;
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 {
DeviceInfoIteratorControlHandle { 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 DeviceInfoIteratorRequestStream {
type Item = Result<DeviceInfoIteratorRequest, 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 DeviceInfoIteratorRequestStream 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 {
0x3e24784022ec70f7 => {
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 =
DeviceInfoIteratorControlHandle { inner: this.inner.clone() };
Ok(DeviceInfoIteratorRequest::GetNext {
responder: DeviceInfoIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<DeviceInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum DeviceInfoIteratorRequest {
GetNext { responder: DeviceInfoIteratorGetNextResponder },
}
impl DeviceInfoIteratorRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_get_next(self) -> Option<(DeviceInfoIteratorGetNextResponder)> {
if let DeviceInfoIteratorRequest::GetNext { responder } = self {
Some((responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
DeviceInfoIteratorRequest::GetNext { .. } => "get_next",
}
}
}
#[derive(Debug, Clone)]
pub struct DeviceInfoIteratorControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for DeviceInfoIteratorControlHandle {
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 DeviceInfoIteratorControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DeviceInfoIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop<DeviceInfoIteratorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DeviceInfoIteratorGetNextResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DeviceInfoIteratorGetNextResponder {
type ControlHandle = DeviceInfoIteratorControlHandle;
fn control_handle(&self) -> &DeviceInfoIteratorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DeviceInfoIteratorGetNextResponder {
pub fn send(self, mut drivers: &[DeviceInfo]) -> Result<(), fidl::Error> {
let _result = self.send_raw(drivers);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut drivers: &[DeviceInfo]) -> Result<(), fidl::Error> {
let _result = self.send_raw(drivers);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut drivers: &[DeviceInfo]) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DeviceInfoIteratorGetNextResponse>(
(drivers,),
self.tx_id,
0x3e24784022ec70f7,
fidl::encoding::DynamicFlags::empty(),
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverDevelopmentMarker;
impl fidl::endpoints::ProtocolMarker for DriverDevelopmentMarker {
type Proxy = DriverDevelopmentProxy;
type RequestStream = DriverDevelopmentRequestStream;
const DEBUG_NAME: &'static str = "fuchsia.driver.development.DriverDevelopment";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DriverDevelopmentMarker {}
pub type DriverDevelopmentRestartDriverHostsResult = Result<u32, i32>;
pub type DriverDevelopmentBindAllUnboundNodesResult = Result<Vec<NodeBindingInfo>, i32>;
pub type DriverDevelopmentAddTestNodeResult = Result<(), fidl_fuchsia_driver_framework::NodeError>;
pub type DriverDevelopmentRemoveTestNodeResult = Result<(), i32>;
pub trait DriverDevelopmentProxyInterface: Send + Sync {
fn r#get_driver_info(
&self,
driver_filter: &[String],
iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error>;
fn r#get_composite_node_specs(
&self,
name_filter: Option<&str>,
iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error>;
type DisableMatchWithDriverUrlResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
+ Send;
fn r#disable_match_with_driver_url(
&self,
driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::DisableMatchWithDriverUrlResponseFut;
type ReEnableMatchWithDriverUrlResponseFut: std::future::Future<
Output = Result<DriverIndexReEnableMatchWithDriverUrlResult, fidl::Error>,
> + Send;
fn r#re_enable_match_with_driver_url(
&self,
driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::ReEnableMatchWithDriverUrlResponseFut;
type RestartDriverHostsResponseFut: std::future::Future<Output = Result<DriverDevelopmentRestartDriverHostsResult, fidl::Error>>
+ Send;
fn r#restart_driver_hosts(
&self,
driver_path: &str,
rematch_flags: RematchFlags,
) -> Self::RestartDriverHostsResponseFut;
fn r#get_device_info(
&self,
device_filter: &[String],
iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
exact_match: bool,
) -> Result<(), fidl::Error>;
fn r#get_composite_info(
&self,
iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
) -> Result<(), fidl::Error>;
type BindAllUnboundNodesResponseFut: std::future::Future<
Output = Result<DriverDevelopmentBindAllUnboundNodesResult, fidl::Error>,
> + Send;
fn r#bind_all_unbound_nodes(&self) -> Self::BindAllUnboundNodesResponseFut;
type IsDfv2ResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
fn r#is_dfv2(&self) -> Self::IsDfv2ResponseFut;
type AddTestNodeResponseFut: std::future::Future<Output = Result<DriverDevelopmentAddTestNodeResult, fidl::Error>>
+ Send;
fn r#add_test_node(&self, args: &TestNodeAddArgs) -> Self::AddTestNodeResponseFut;
type RemoveTestNodeResponseFut: std::future::Future<Output = Result<DriverDevelopmentRemoveTestNodeResult, fidl::Error>>
+ Send;
fn r#remove_test_node(&self, name: &str) -> Self::RemoveTestNodeResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DriverDevelopmentSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl DriverDevelopmentSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<DriverDevelopmentMarker 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<DriverDevelopmentEvent, fidl::Error> {
DriverDevelopmentEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#get_driver_info(
&self,
mut driver_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetDriverInfoRequest>(
(driver_filter, iterator),
0x5f51f1ceaa350c28,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#get_composite_node_specs(
&self,
mut name_filter: Option<&str>,
mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetCompositeNodeSpecsRequest>(
(name_filter, iterator),
0x43104254014654e6,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#disable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
DriverIndexDisableMatchWithDriverUrlRequest,
fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
>(
(driver_url,),
0x5ab4b815cc8995b0,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<DriverDevelopmentMarker>("disable_match_with_driver_url")?;
Ok(_response)
}
pub fn r#re_enable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
___deadline: zx::Time,
) -> Result<DriverIndexReEnableMatchWithDriverUrlResult, fidl::Error> {
let _response = self.client.send_query::<
DriverIndexReEnableMatchWithDriverUrlRequest,
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
>(
(driver_url,),
0x102717ab190e9c7,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<DriverDevelopmentMarker>("re_enable_match_with_driver_url")?;
Ok(_response.map(|x| x))
}
pub fn r#restart_driver_hosts(
&self,
mut driver_path: &str,
mut rematch_flags: RematchFlags,
___deadline: zx::Time,
) -> Result<DriverDevelopmentRestartDriverHostsResult, fidl::Error> {
let _response = self.client.send_query::<
DriverDevelopmentRestartDriverHostsRequest,
fidl::encoding::FlexibleResultType<DriverDevelopmentRestartDriverHostsResponse, i32>,
>(
(driver_path, rematch_flags,),
0x41f109f152ecfe00,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<DriverDevelopmentMarker>("restart_driver_hosts")?;
Ok(_response.map(|x| x.count))
}
pub fn r#get_device_info(
&self,
mut device_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
mut exact_match: bool,
) -> Result<(), fidl::Error> {
self.client.send::<DriverDevelopmentGetDeviceInfoRequest>(
(device_filter, iterator, exact_match),
0x47c15054d1954812,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#get_composite_info(
&self,
mut iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverDevelopmentGetCompositeInfoRequest>(
(iterator,),
0x7b6e681d998a88,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#bind_all_unbound_nodes(
&self,
___deadline: zx::Time,
) -> Result<DriverDevelopmentBindAllUnboundNodesResult, fidl::Error> {
let _response =
self.client
.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::FlexibleResultType<
DriverDevelopmentBindAllUnboundNodesResponse,
i32,
>>(
(), 0xaeb067b90843cb6, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<DriverDevelopmentMarker>("bind_all_unbound_nodes")?;
Ok(_response.map(|x| x.binding_result))
}
pub fn r#is_dfv2(&self, ___deadline: zx::Time) -> Result<bool, fidl::Error> {
let _response = self.client.send_query::<
fidl::encoding::EmptyPayload,
fidl::encoding::FlexibleType<DriverDevelopmentIsDfv2Response>,
>(
(),
0x4f8e78c763350ee8,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<DriverDevelopmentMarker>("is_dfv2")?;
Ok(_response.response)
}
pub fn r#add_test_node(
&self,
mut args: &TestNodeAddArgs,
___deadline: zx::Time,
) -> Result<DriverDevelopmentAddTestNodeResult, fidl::Error> {
let _response = self
.client
.send_query::<DriverDevelopmentAddTestNodeRequest, fidl::encoding::FlexibleResultType<
fidl::encoding::EmptyStruct,
fidl_fuchsia_driver_framework::NodeError,
>>(
(args,), 0x7462b4a0ecbd6903, fidl::encoding::DynamicFlags::FLEXIBLE, ___deadline
)?
.into_result::<DriverDevelopmentMarker>("add_test_node")?;
Ok(_response.map(|x| x))
}
pub fn r#remove_test_node(
&self,
mut name: &str,
___deadline: zx::Time,
) -> Result<DriverDevelopmentRemoveTestNodeResult, fidl::Error> {
let _response = self.client.send_query::<
DriverDevelopmentRemoveTestNodeRequest,
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
>(
(name,),
0x674bca94f5bd93e6,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<DriverDevelopmentMarker>("remove_test_node")?;
Ok(_response.map(|x| x))
}
}
#[derive(Debug, Clone)]
pub struct DriverDevelopmentProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for DriverDevelopmentProxy {
type Protocol = DriverDevelopmentMarker;
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 DriverDevelopmentProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<DriverDevelopmentMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> DriverDevelopmentEventStream {
DriverDevelopmentEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#get_driver_info(
&self,
mut driver_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
DriverDevelopmentProxyInterface::r#get_driver_info(self, driver_filter, iterator)
}
pub fn r#get_composite_node_specs(
&self,
mut name_filter: Option<&str>,
mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error> {
DriverDevelopmentProxyInterface::r#get_composite_node_specs(self, name_filter, iterator)
}
pub fn r#disable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> fidl::client::QueryResponseFut<()> {
DriverDevelopmentProxyInterface::r#disable_match_with_driver_url(self, driver_url)
}
pub fn r#re_enable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> fidl::client::QueryResponseFut<DriverIndexReEnableMatchWithDriverUrlResult> {
DriverDevelopmentProxyInterface::r#re_enable_match_with_driver_url(self, driver_url)
}
pub fn r#restart_driver_hosts(
&self,
mut driver_path: &str,
mut rematch_flags: RematchFlags,
) -> fidl::client::QueryResponseFut<DriverDevelopmentRestartDriverHostsResult> {
DriverDevelopmentProxyInterface::r#restart_driver_hosts(self, driver_path, rematch_flags)
}
pub fn r#get_device_info(
&self,
mut device_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
mut exact_match: bool,
) -> Result<(), fidl::Error> {
DriverDevelopmentProxyInterface::r#get_device_info(
self,
device_filter,
iterator,
exact_match,
)
}
pub fn r#get_composite_info(
&self,
mut iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
DriverDevelopmentProxyInterface::r#get_composite_info(self, iterator)
}
pub fn r#bind_all_unbound_nodes(
&self,
) -> fidl::client::QueryResponseFut<DriverDevelopmentBindAllUnboundNodesResult> {
DriverDevelopmentProxyInterface::r#bind_all_unbound_nodes(self)
}
pub fn r#is_dfv2(&self) -> fidl::client::QueryResponseFut<bool> {
DriverDevelopmentProxyInterface::r#is_dfv2(self)
}
pub fn r#add_test_node(
&self,
mut args: &TestNodeAddArgs,
) -> fidl::client::QueryResponseFut<DriverDevelopmentAddTestNodeResult> {
DriverDevelopmentProxyInterface::r#add_test_node(self, args)
}
pub fn r#remove_test_node(
&self,
mut name: &str,
) -> fidl::client::QueryResponseFut<DriverDevelopmentRemoveTestNodeResult> {
DriverDevelopmentProxyInterface::r#remove_test_node(self, name)
}
}
impl DriverDevelopmentProxyInterface for DriverDevelopmentProxy {
fn r#get_driver_info(
&self,
mut driver_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetDriverInfoRequest>(
(driver_filter, iterator),
0x5f51f1ceaa350c28,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
fn r#get_composite_node_specs(
&self,
mut name_filter: Option<&str>,
mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetCompositeNodeSpecsRequest>(
(name_filter, iterator),
0x43104254014654e6,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
type DisableMatchWithDriverUrlResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::DisableMatchWithDriverUrlResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
0x5ab4b815cc8995b0,
>(_buf?)?
.into_result::<DriverDevelopmentMarker>("disable_match_with_driver_url")?;
Ok(_response)
}
self.client.send_query_and_decode::<DriverIndexDisableMatchWithDriverUrlRequest, ()>(
(driver_url,),
0x5ab4b815cc8995b0,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type ReEnableMatchWithDriverUrlResponseFut =
fidl::client::QueryResponseFut<DriverIndexReEnableMatchWithDriverUrlResult>;
fn r#re_enable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::ReEnableMatchWithDriverUrlResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DriverIndexReEnableMatchWithDriverUrlResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
0x102717ab190e9c7,
>(_buf?)?
.into_result::<DriverDevelopmentMarker>("re_enable_match_with_driver_url")?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
DriverIndexReEnableMatchWithDriverUrlRequest,
DriverIndexReEnableMatchWithDriverUrlResult,
>(
(driver_url,),
0x102717ab190e9c7,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type RestartDriverHostsResponseFut =
fidl::client::QueryResponseFut<DriverDevelopmentRestartDriverHostsResult>;
fn r#restart_driver_hosts(
&self,
mut driver_path: &str,
mut rematch_flags: RematchFlags,
) -> Self::RestartDriverHostsResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DriverDevelopmentRestartDriverHostsResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<
DriverDevelopmentRestartDriverHostsResponse,
i32,
>,
0x41f109f152ecfe00,
>(_buf?)?
.into_result::<DriverDevelopmentMarker>("restart_driver_hosts")?;
Ok(_response.map(|x| x.count))
}
self.client.send_query_and_decode::<
DriverDevelopmentRestartDriverHostsRequest,
DriverDevelopmentRestartDriverHostsResult,
>(
(driver_path, rematch_flags,),
0x41f109f152ecfe00,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
fn r#get_device_info(
&self,
mut device_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
mut exact_match: bool,
) -> Result<(), fidl::Error> {
self.client.send::<DriverDevelopmentGetDeviceInfoRequest>(
(device_filter, iterator, exact_match),
0x47c15054d1954812,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
fn r#get_composite_info(
&self,
mut iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverDevelopmentGetCompositeInfoRequest>(
(iterator,),
0x7b6e681d998a88,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
type BindAllUnboundNodesResponseFut =
fidl::client::QueryResponseFut<DriverDevelopmentBindAllUnboundNodesResult>;
fn r#bind_all_unbound_nodes(&self) -> Self::BindAllUnboundNodesResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DriverDevelopmentBindAllUnboundNodesResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<
DriverDevelopmentBindAllUnboundNodesResponse,
i32,
>,
0xaeb067b90843cb6,
>(_buf?)?
.into_result::<DriverDevelopmentMarker>("bind_all_unbound_nodes")?;
Ok(_response.map(|x| x.binding_result))
}
self.client.send_query_and_decode::<
fidl::encoding::EmptyPayload,
DriverDevelopmentBindAllUnboundNodesResult,
>(
(),
0xaeb067b90843cb6,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type IsDfv2ResponseFut = fidl::client::QueryResponseFut<bool>;
fn r#is_dfv2(&self) -> Self::IsDfv2ResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<bool, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleType<DriverDevelopmentIsDfv2Response>,
0x4f8e78c763350ee8,
>(_buf?)?
.into_result::<DriverDevelopmentMarker>("is_dfv2")?;
Ok(_response.response)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, bool>(
(),
0x4f8e78c763350ee8,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type AddTestNodeResponseFut =
fidl::client::QueryResponseFut<DriverDevelopmentAddTestNodeResult>;
fn r#add_test_node(&self, mut args: &TestNodeAddArgs) -> Self::AddTestNodeResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DriverDevelopmentAddTestNodeResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<
fidl::encoding::EmptyStruct,
fidl_fuchsia_driver_framework::NodeError,
>,
0x7462b4a0ecbd6903,
>(_buf?)?
.into_result::<DriverDevelopmentMarker>("add_test_node")?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
DriverDevelopmentAddTestNodeRequest,
DriverDevelopmentAddTestNodeResult,
>(
(args,),
0x7462b4a0ecbd6903,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type RemoveTestNodeResponseFut =
fidl::client::QueryResponseFut<DriverDevelopmentRemoveTestNodeResult>;
fn r#remove_test_node(&self, mut name: &str) -> Self::RemoveTestNodeResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DriverDevelopmentRemoveTestNodeResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
0x674bca94f5bd93e6,
>(_buf?)?
.into_result::<DriverDevelopmentMarker>("remove_test_node")?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
DriverDevelopmentRemoveTestNodeRequest,
DriverDevelopmentRemoveTestNodeResult,
>(
(name,),
0x674bca94f5bd93e6,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
}
pub struct DriverDevelopmentEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for DriverDevelopmentEventStream {}
impl futures::stream::FusedStream for DriverDevelopmentEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for DriverDevelopmentEventStream {
type Item = Result<DriverDevelopmentEvent, 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(DriverDevelopmentEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum DriverDevelopmentEvent {
#[non_exhaustive]
_UnknownEvent {
ordinal: u64,
},
}
impl DriverDevelopmentEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<DriverDevelopmentEvent, 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 {
_ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(DriverDevelopmentEvent::_UnknownEvent { ordinal: tx_header.ordinal })
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name:
<DriverDevelopmentMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct DriverDevelopmentRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for DriverDevelopmentRequestStream {}
impl futures::stream::FusedStream for DriverDevelopmentRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for DriverDevelopmentRequestStream {
type Protocol = DriverDevelopmentMarker;
type ControlHandle = DriverDevelopmentControlHandle;
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 {
DriverDevelopmentControlHandle { 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 DriverDevelopmentRequestStream {
type Item = Result<DriverDevelopmentRequest, 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 DriverDevelopmentRequestStream 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 {
0x5f51f1ceaa350c28 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DriverIndexGetDriverInfoRequest);
fidl::encoding::Decoder::decode_into::<DriverIndexGetDriverInfoRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::GetDriverInfo {
driver_filter: req.driver_filter,
iterator: req.iterator,
control_handle,
})
}
0x43104254014654e6 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DriverIndexGetCompositeNodeSpecsRequest);
fidl::encoding::Decoder::decode_into::<DriverIndexGetCompositeNodeSpecsRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::GetCompositeNodeSpecs {
name_filter: req.name_filter,
iterator: req.iterator,
control_handle,
})
}
0x5ab4b815cc8995b0 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverIndexDisableMatchWithDriverUrlRequest);
fidl::encoding::Decoder::decode_into::<
DriverIndexDisableMatchWithDriverUrlRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::DisableMatchWithDriverUrl {
driver_url: req.driver_url,
responder: DriverDevelopmentDisableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x102717ab190e9c7 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverIndexReEnableMatchWithDriverUrlRequest);
fidl::encoding::Decoder::decode_into::<
DriverIndexReEnableMatchWithDriverUrlRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::ReEnableMatchWithDriverUrl {
driver_url: req.driver_url,
responder: DriverDevelopmentReEnableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x41f109f152ecfe00 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverDevelopmentRestartDriverHostsRequest);
fidl::encoding::Decoder::decode_into::<
DriverDevelopmentRestartDriverHostsRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::RestartDriverHosts {
driver_path: req.driver_path,
rematch_flags: req.rematch_flags,
responder: DriverDevelopmentRestartDriverHostsResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x47c15054d1954812 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DriverDevelopmentGetDeviceInfoRequest);
fidl::encoding::Decoder::decode_into::<DriverDevelopmentGetDeviceInfoRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::GetDeviceInfo {
device_filter: req.device_filter,
iterator: req.iterator,
exact_match: req.exact_match,
control_handle,
})
}
0x7b6e681d998a88 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DriverDevelopmentGetCompositeInfoRequest);
fidl::encoding::Decoder::decode_into::<DriverDevelopmentGetCompositeInfoRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::GetCompositeInfo {
iterator: req.iterator,
control_handle,
})
}
0xaeb067b90843cb6 => {
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 =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::BindAllUnboundNodes {
responder: DriverDevelopmentBindAllUnboundNodesResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x4f8e78c763350ee8 => {
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 =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::IsDfv2 {
responder: DriverDevelopmentIsDfv2Responder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x7462b4a0ecbd6903 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverDevelopmentAddTestNodeRequest);
fidl::encoding::Decoder::decode_into::<DriverDevelopmentAddTestNodeRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::AddTestNode {
args: req.args,
responder: DriverDevelopmentAddTestNodeResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x674bca94f5bd93e6 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverDevelopmentRemoveTestNodeRequest);
fidl::encoding::Decoder::decode_into::<DriverDevelopmentRemoveTestNodeRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle =
DriverDevelopmentControlHandle { inner: this.inner.clone() };
Ok(DriverDevelopmentRequest::RemoveTestNode {
name: req.name,
responder: DriverDevelopmentRemoveTestNodeResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ if header.tx_id == 0
&& header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
{
Ok(DriverDevelopmentRequest::_UnknownMethod {
ordinal: header.ordinal,
control_handle: DriverDevelopmentControlHandle {
inner: this.inner.clone(),
},
method_type: fidl::MethodType::OneWay,
})
}
_ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
this.inner.send_framework_err(
fidl::encoding::FrameworkErr::UnknownMethod,
header.tx_id,
header.ordinal,
header.dynamic_flags(),
(bytes, handles),
)?;
Ok(DriverDevelopmentRequest::_UnknownMethod {
ordinal: header.ordinal,
control_handle: DriverDevelopmentControlHandle {
inner: this.inner.clone(),
},
method_type: fidl::MethodType::TwoWay,
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<DriverDevelopmentMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum DriverDevelopmentRequest {
GetDriverInfo {
driver_filter: Vec<String>,
iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
control_handle: DriverDevelopmentControlHandle,
},
GetCompositeNodeSpecs {
name_filter: Option<String>,
iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
control_handle: DriverDevelopmentControlHandle,
},
DisableMatchWithDriverUrl {
driver_url: fidl_fuchsia_pkg::PackageUrl,
responder: DriverDevelopmentDisableMatchWithDriverUrlResponder,
},
ReEnableMatchWithDriverUrl {
driver_url: fidl_fuchsia_pkg::PackageUrl,
responder: DriverDevelopmentReEnableMatchWithDriverUrlResponder,
},
RestartDriverHosts {
driver_path: String,
rematch_flags: RematchFlags,
responder: DriverDevelopmentRestartDriverHostsResponder,
},
GetDeviceInfo {
device_filter: Vec<String>,
iterator: fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
exact_match: bool,
control_handle: DriverDevelopmentControlHandle,
},
GetCompositeInfo {
iterator: fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
control_handle: DriverDevelopmentControlHandle,
},
BindAllUnboundNodes {
responder: DriverDevelopmentBindAllUnboundNodesResponder,
},
IsDfv2 {
responder: DriverDevelopmentIsDfv2Responder,
},
AddTestNode {
args: TestNodeAddArgs,
responder: DriverDevelopmentAddTestNodeResponder,
},
RemoveTestNode {
name: String,
responder: DriverDevelopmentRemoveTestNodeResponder,
},
#[non_exhaustive]
_UnknownMethod {
ordinal: u64,
control_handle: DriverDevelopmentControlHandle,
method_type: fidl::MethodType,
},
}
impl DriverDevelopmentRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_get_driver_info(
self,
) -> Option<(
Vec<String>,
fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
DriverDevelopmentControlHandle,
)> {
if let DriverDevelopmentRequest::GetDriverInfo { driver_filter, iterator, control_handle } =
self
{
Some((driver_filter, iterator, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_composite_node_specs(
self,
) -> Option<(
Option<String>,
fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
DriverDevelopmentControlHandle,
)> {
if let DriverDevelopmentRequest::GetCompositeNodeSpecs {
name_filter,
iterator,
control_handle,
} = self
{
Some((name_filter, iterator, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disable_match_with_driver_url(
self,
) -> Option<(fidl_fuchsia_pkg::PackageUrl, DriverDevelopmentDisableMatchWithDriverUrlResponder)>
{
if let DriverDevelopmentRequest::DisableMatchWithDriverUrl { driver_url, responder } = self
{
Some((driver_url, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_re_enable_match_with_driver_url(
self,
) -> Option<(fidl_fuchsia_pkg::PackageUrl, DriverDevelopmentReEnableMatchWithDriverUrlResponder)>
{
if let DriverDevelopmentRequest::ReEnableMatchWithDriverUrl { driver_url, responder } = self
{
Some((driver_url, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_restart_driver_hosts(
self,
) -> Option<(String, RematchFlags, DriverDevelopmentRestartDriverHostsResponder)> {
if let DriverDevelopmentRequest::RestartDriverHosts {
driver_path,
rematch_flags,
responder,
} = self
{
Some((driver_path, rematch_flags, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_device_info(
self,
) -> Option<(
Vec<String>,
fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>,
bool,
DriverDevelopmentControlHandle,
)> {
if let DriverDevelopmentRequest::GetDeviceInfo {
device_filter,
iterator,
exact_match,
control_handle,
} = self
{
Some((device_filter, iterator, exact_match, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_composite_info(
self,
) -> Option<(
fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
DriverDevelopmentControlHandle,
)> {
if let DriverDevelopmentRequest::GetCompositeInfo { iterator, control_handle } = self {
Some((iterator, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_bind_all_unbound_nodes(
self,
) -> Option<(DriverDevelopmentBindAllUnboundNodesResponder)> {
if let DriverDevelopmentRequest::BindAllUnboundNodes { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_is_dfv2(self) -> Option<(DriverDevelopmentIsDfv2Responder)> {
if let DriverDevelopmentRequest::IsDfv2 { responder } = self {
Some((responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_add_test_node(
self,
) -> Option<(TestNodeAddArgs, DriverDevelopmentAddTestNodeResponder)> {
if let DriverDevelopmentRequest::AddTestNode { args, responder } = self {
Some((args, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_remove_test_node(
self,
) -> Option<(String, DriverDevelopmentRemoveTestNodeResponder)> {
if let DriverDevelopmentRequest::RemoveTestNode { name, responder } = self {
Some((name, responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
DriverDevelopmentRequest::GetDriverInfo { .. } => "get_driver_info",
DriverDevelopmentRequest::GetCompositeNodeSpecs { .. } => "get_composite_node_specs",
DriverDevelopmentRequest::DisableMatchWithDriverUrl { .. } => {
"disable_match_with_driver_url"
}
DriverDevelopmentRequest::ReEnableMatchWithDriverUrl { .. } => {
"re_enable_match_with_driver_url"
}
DriverDevelopmentRequest::RestartDriverHosts { .. } => "restart_driver_hosts",
DriverDevelopmentRequest::GetDeviceInfo { .. } => "get_device_info",
DriverDevelopmentRequest::GetCompositeInfo { .. } => "get_composite_info",
DriverDevelopmentRequest::BindAllUnboundNodes { .. } => "bind_all_unbound_nodes",
DriverDevelopmentRequest::IsDfv2 { .. } => "is_dfv2",
DriverDevelopmentRequest::AddTestNode { .. } => "add_test_node",
DriverDevelopmentRequest::RemoveTestNode { .. } => "remove_test_node",
DriverDevelopmentRequest::_UnknownMethod {
method_type: fidl::MethodType::OneWay,
..
} => "unknown one-way method",
DriverDevelopmentRequest::_UnknownMethod {
method_type: fidl::MethodType::TwoWay,
..
} => "unknown two-way method",
}
}
}
#[derive(Debug, Clone)]
pub struct DriverDevelopmentControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for DriverDevelopmentControlHandle {
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 DriverDevelopmentControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverDevelopmentDisableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverDevelopmentDisableMatchWithDriverUrlResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverDevelopmentDisableMatchWithDriverUrlResponder {
type ControlHandle = DriverDevelopmentControlHandle;
fn control_handle(&self) -> &DriverDevelopmentControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverDevelopmentDisableMatchWithDriverUrlResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
fidl::encoding::Flexible::new(()),
self.tx_id,
0x5ab4b815cc8995b0,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverDevelopmentReEnableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverDevelopmentReEnableMatchWithDriverUrlResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverDevelopmentReEnableMatchWithDriverUrlResponder {
type ControlHandle = DriverDevelopmentControlHandle;
fn control_handle(&self) -> &DriverDevelopmentControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverDevelopmentReEnableMatchWithDriverUrlResponder {
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::FlexibleResultType<
fidl::encoding::EmptyStruct,
i32,
>>(
fidl::encoding::FlexibleResult::new(result),
self.tx_id,
0x102717ab190e9c7,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverDevelopmentRestartDriverHostsResponder {
control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverDevelopmentRestartDriverHostsResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverDevelopmentRestartDriverHostsResponder {
type ControlHandle = DriverDevelopmentControlHandle;
fn control_handle(&self) -> &DriverDevelopmentControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverDevelopmentRestartDriverHostsResponder {
pub fn send(self, mut result: Result<u32, 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<u32, i32>) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<u32, i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
DriverDevelopmentRestartDriverHostsResponse,
i32,
>>(
fidl::encoding::FlexibleResult::new(result.map(|count| (count,))),
self.tx_id,
0x41f109f152ecfe00,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverDevelopmentBindAllUnboundNodesResponder {
control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverDevelopmentBindAllUnboundNodesResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverDevelopmentBindAllUnboundNodesResponder {
type ControlHandle = DriverDevelopmentControlHandle;
fn control_handle(&self) -> &DriverDevelopmentControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverDevelopmentBindAllUnboundNodesResponder {
pub fn send(self, mut result: Result<&[NodeBindingInfo], 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<&[NodeBindingInfo], i32>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut result: Result<&[NodeBindingInfo], i32>) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
DriverDevelopmentBindAllUnboundNodesResponse,
i32,
>>(
fidl::encoding::FlexibleResult::new(result.map(|binding_result| (binding_result,))),
self.tx_id,
0xaeb067b90843cb6,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverDevelopmentIsDfv2Responder {
control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverDevelopmentIsDfv2Responder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverDevelopmentIsDfv2Responder {
type ControlHandle = DriverDevelopmentControlHandle;
fn control_handle(&self) -> &DriverDevelopmentControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverDevelopmentIsDfv2Responder {
pub fn send(self, mut response: bool) -> Result<(), fidl::Error> {
let _result = self.send_raw(response);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut response: bool) -> Result<(), fidl::Error> {
let _result = self.send_raw(response);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut response: bool) -> Result<(), fidl::Error> {
self.control_handle
.inner
.send::<fidl::encoding::FlexibleType<DriverDevelopmentIsDfv2Response>>(
fidl::encoding::Flexible::new((response,)),
self.tx_id,
0x4f8e78c763350ee8,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverDevelopmentAddTestNodeResponder {
control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverDevelopmentAddTestNodeResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverDevelopmentAddTestNodeResponder {
type ControlHandle = DriverDevelopmentControlHandle;
fn control_handle(&self) -> &DriverDevelopmentControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverDevelopmentAddTestNodeResponder {
pub fn send(
self,
mut result: Result<(), fidl_fuchsia_driver_framework::NodeError>,
) -> 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_fuchsia_driver_framework::NodeError>,
) -> Result<(), fidl::Error> {
let _result = self.send_raw(result);
self.drop_without_shutdown();
_result
}
fn send_raw(
&self,
mut result: Result<(), fidl_fuchsia_driver_framework::NodeError>,
) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
fidl::encoding::EmptyStruct,
fidl_fuchsia_driver_framework::NodeError,
>>(
fidl::encoding::FlexibleResult::new(result),
self.tx_id,
0x7462b4a0ecbd6903,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverDevelopmentRemoveTestNodeResponder {
control_handle: std::mem::ManuallyDrop<DriverDevelopmentControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverDevelopmentRemoveTestNodeResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverDevelopmentRemoveTestNodeResponder {
type ControlHandle = DriverDevelopmentControlHandle;
fn control_handle(&self) -> &DriverDevelopmentControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverDevelopmentRemoveTestNodeResponder {
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::FlexibleResultType<
fidl::encoding::EmptyStruct,
i32,
>>(
fidl::encoding::FlexibleResult::new(result),
self.tx_id,
0x674bca94f5bd93e6,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverIndexMarker;
impl fidl::endpoints::ProtocolMarker for DriverIndexMarker {
type Proxy = DriverIndexProxy;
type RequestStream = DriverIndexRequestStream;
const DEBUG_NAME: &'static str = "fuchsia.driver.development.DriverIndex";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DriverIndexMarker {}
pub type DriverIndexReEnableMatchWithDriverUrlResult = Result<(), i32>;
pub trait DriverIndexProxyInterface: Send + Sync {
fn r#get_driver_info(
&self,
driver_filter: &[String],
iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error>;
fn r#get_composite_node_specs(
&self,
name_filter: Option<&str>,
iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error>;
type DisableMatchWithDriverUrlResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
+ Send;
fn r#disable_match_with_driver_url(
&self,
driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::DisableMatchWithDriverUrlResponseFut;
type ReEnableMatchWithDriverUrlResponseFut: std::future::Future<
Output = Result<DriverIndexReEnableMatchWithDriverUrlResult, fidl::Error>,
> + Send;
fn r#re_enable_match_with_driver_url(
&self,
driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::ReEnableMatchWithDriverUrlResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DriverIndexSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl DriverIndexSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name = <DriverIndexMarker 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<DriverIndexEvent, fidl::Error> {
DriverIndexEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#get_driver_info(
&self,
mut driver_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetDriverInfoRequest>(
(driver_filter, iterator),
0x5f51f1ceaa350c28,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#get_composite_node_specs(
&self,
mut name_filter: Option<&str>,
mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetCompositeNodeSpecsRequest>(
(name_filter, iterator),
0x43104254014654e6,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
pub fn r#disable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
___deadline: zx::Time,
) -> Result<(), fidl::Error> {
let _response = self.client.send_query::<
DriverIndexDisableMatchWithDriverUrlRequest,
fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
>(
(driver_url,),
0x5ab4b815cc8995b0,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<DriverIndexMarker>("disable_match_with_driver_url")?;
Ok(_response)
}
pub fn r#re_enable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
___deadline: zx::Time,
) -> Result<DriverIndexReEnableMatchWithDriverUrlResult, fidl::Error> {
let _response = self.client.send_query::<
DriverIndexReEnableMatchWithDriverUrlRequest,
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
>(
(driver_url,),
0x102717ab190e9c7,
fidl::encoding::DynamicFlags::FLEXIBLE,
___deadline,
)?
.into_result::<DriverIndexMarker>("re_enable_match_with_driver_url")?;
Ok(_response.map(|x| x))
}
}
#[derive(Debug, Clone)]
pub struct DriverIndexProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for DriverIndexProxy {
type Protocol = DriverIndexMarker;
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 DriverIndexProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name = <DriverIndexMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> DriverIndexEventStream {
DriverIndexEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#get_driver_info(
&self,
mut driver_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
DriverIndexProxyInterface::r#get_driver_info(self, driver_filter, iterator)
}
pub fn r#get_composite_node_specs(
&self,
mut name_filter: Option<&str>,
mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error> {
DriverIndexProxyInterface::r#get_composite_node_specs(self, name_filter, iterator)
}
pub fn r#disable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> fidl::client::QueryResponseFut<()> {
DriverIndexProxyInterface::r#disable_match_with_driver_url(self, driver_url)
}
pub fn r#re_enable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> fidl::client::QueryResponseFut<DriverIndexReEnableMatchWithDriverUrlResult> {
DriverIndexProxyInterface::r#re_enable_match_with_driver_url(self, driver_url)
}
}
impl DriverIndexProxyInterface for DriverIndexProxy {
fn r#get_driver_info(
&self,
mut driver_filter: &[String],
mut iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetDriverInfoRequest>(
(driver_filter, iterator),
0x5f51f1ceaa350c28,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
fn r#get_composite_node_specs(
&self,
mut name_filter: Option<&str>,
mut iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
) -> Result<(), fidl::Error> {
self.client.send::<DriverIndexGetCompositeNodeSpecsRequest>(
(name_filter, iterator),
0x43104254014654e6,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
type DisableMatchWithDriverUrlResponseFut = fidl::client::QueryResponseFut<()>;
fn r#disable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::DisableMatchWithDriverUrlResponseFut {
fn _decode(mut _buf: Result<fidl::MessageBufEtc, fidl::Error>) -> Result<(), fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
0x5ab4b815cc8995b0,
>(_buf?)?
.into_result::<DriverIndexMarker>("disable_match_with_driver_url")?;
Ok(_response)
}
self.client.send_query_and_decode::<DriverIndexDisableMatchWithDriverUrlRequest, ()>(
(driver_url,),
0x5ab4b815cc8995b0,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
type ReEnableMatchWithDriverUrlResponseFut =
fidl::client::QueryResponseFut<DriverIndexReEnableMatchWithDriverUrlResult>;
fn r#re_enable_match_with_driver_url(
&self,
mut driver_url: &fidl_fuchsia_pkg::PackageUrl,
) -> Self::ReEnableMatchWithDriverUrlResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<DriverIndexReEnableMatchWithDriverUrlResult, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
fidl::encoding::FlexibleResultType<fidl::encoding::EmptyStruct, i32>,
0x102717ab190e9c7,
>(_buf?)?
.into_result::<DriverIndexMarker>("re_enable_match_with_driver_url")?;
Ok(_response.map(|x| x))
}
self.client.send_query_and_decode::<
DriverIndexReEnableMatchWithDriverUrlRequest,
DriverIndexReEnableMatchWithDriverUrlResult,
>(
(driver_url,),
0x102717ab190e9c7,
fidl::encoding::DynamicFlags::FLEXIBLE,
_decode,
)
}
}
pub struct DriverIndexEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for DriverIndexEventStream {}
impl futures::stream::FusedStream for DriverIndexEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for DriverIndexEventStream {
type Item = Result<DriverIndexEvent, 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(DriverIndexEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum DriverIndexEvent {
#[non_exhaustive]
_UnknownEvent {
ordinal: u64,
},
}
impl DriverIndexEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<DriverIndexEvent, 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 {
_ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
Ok(DriverIndexEvent::_UnknownEvent { ordinal: tx_header.ordinal })
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: tx_header.ordinal,
protocol_name: <DriverIndexMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct DriverIndexRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for DriverIndexRequestStream {}
impl futures::stream::FusedStream for DriverIndexRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for DriverIndexRequestStream {
type Protocol = DriverIndexMarker;
type ControlHandle = DriverIndexControlHandle;
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 {
DriverIndexControlHandle { 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 DriverIndexRequestStream {
type Item = Result<DriverIndexRequest, 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 DriverIndexRequestStream 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 {
0x5f51f1ceaa350c28 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DriverIndexGetDriverInfoRequest);
fidl::encoding::Decoder::decode_into::<DriverIndexGetDriverInfoRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = DriverIndexControlHandle { inner: this.inner.clone() };
Ok(DriverIndexRequest::GetDriverInfo {
driver_filter: req.driver_filter,
iterator: req.iterator,
control_handle,
})
}
0x43104254014654e6 => {
header.validate_request_tx_id(fidl::MethodType::OneWay)?;
let mut req = fidl::new_empty!(DriverIndexGetCompositeNodeSpecsRequest);
fidl::encoding::Decoder::decode_into::<DriverIndexGetCompositeNodeSpecsRequest>(
&header,
_body_bytes,
handles,
&mut req,
)?;
let control_handle = DriverIndexControlHandle { inner: this.inner.clone() };
Ok(DriverIndexRequest::GetCompositeNodeSpecs {
name_filter: req.name_filter,
iterator: req.iterator,
control_handle,
})
}
0x5ab4b815cc8995b0 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverIndexDisableMatchWithDriverUrlRequest);
fidl::encoding::Decoder::decode_into::<
DriverIndexDisableMatchWithDriverUrlRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle = DriverIndexControlHandle { inner: this.inner.clone() };
Ok(DriverIndexRequest::DisableMatchWithDriverUrl {
driver_url: req.driver_url,
responder: DriverIndexDisableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
0x102717ab190e9c7 => {
header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
let mut req = fidl::new_empty!(DriverIndexReEnableMatchWithDriverUrlRequest);
fidl::encoding::Decoder::decode_into::<
DriverIndexReEnableMatchWithDriverUrlRequest,
>(&header, _body_bytes, handles, &mut req)?;
let control_handle = DriverIndexControlHandle { inner: this.inner.clone() };
Ok(DriverIndexRequest::ReEnableMatchWithDriverUrl {
driver_url: req.driver_url,
responder: DriverIndexReEnableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ if header.tx_id == 0
&& header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
{
Ok(DriverIndexRequest::_UnknownMethod {
ordinal: header.ordinal,
control_handle: DriverIndexControlHandle { inner: this.inner.clone() },
method_type: fidl::MethodType::OneWay,
})
}
_ if header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
this.inner.send_framework_err(
fidl::encoding::FrameworkErr::UnknownMethod,
header.tx_id,
header.ordinal,
header.dynamic_flags(),
(bytes, handles),
)?;
Ok(DriverIndexRequest::_UnknownMethod {
ordinal: header.ordinal,
control_handle: DriverIndexControlHandle { inner: this.inner.clone() },
method_type: fidl::MethodType::TwoWay,
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<DriverIndexMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum DriverIndexRequest {
GetDriverInfo {
driver_filter: Vec<String>,
iterator: fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
control_handle: DriverIndexControlHandle,
},
GetCompositeNodeSpecs {
name_filter: Option<String>,
iterator: fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
control_handle: DriverIndexControlHandle,
},
DisableMatchWithDriverUrl {
driver_url: fidl_fuchsia_pkg::PackageUrl,
responder: DriverIndexDisableMatchWithDriverUrlResponder,
},
ReEnableMatchWithDriverUrl {
driver_url: fidl_fuchsia_pkg::PackageUrl,
responder: DriverIndexReEnableMatchWithDriverUrlResponder,
},
#[non_exhaustive]
_UnknownMethod {
ordinal: u64,
control_handle: DriverIndexControlHandle,
method_type: fidl::MethodType,
},
}
impl DriverIndexRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_get_driver_info(
self,
) -> Option<(
Vec<String>,
fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>,
DriverIndexControlHandle,
)> {
if let DriverIndexRequest::GetDriverInfo { driver_filter, iterator, control_handle } = self
{
Some((driver_filter, iterator, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_get_composite_node_specs(
self,
) -> Option<(
Option<String>,
fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
DriverIndexControlHandle,
)> {
if let DriverIndexRequest::GetCompositeNodeSpecs { name_filter, iterator, control_handle } =
self
{
Some((name_filter, iterator, control_handle))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_disable_match_with_driver_url(
self,
) -> Option<(fidl_fuchsia_pkg::PackageUrl, DriverIndexDisableMatchWithDriverUrlResponder)> {
if let DriverIndexRequest::DisableMatchWithDriverUrl { driver_url, responder } = self {
Some((driver_url, responder))
} else {
None
}
}
#[allow(irrefutable_let_patterns)]
pub fn into_re_enable_match_with_driver_url(
self,
) -> Option<(fidl_fuchsia_pkg::PackageUrl, DriverIndexReEnableMatchWithDriverUrlResponder)>
{
if let DriverIndexRequest::ReEnableMatchWithDriverUrl { driver_url, responder } = self {
Some((driver_url, responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
DriverIndexRequest::GetDriverInfo { .. } => "get_driver_info",
DriverIndexRequest::GetCompositeNodeSpecs { .. } => "get_composite_node_specs",
DriverIndexRequest::DisableMatchWithDriverUrl { .. } => "disable_match_with_driver_url",
DriverIndexRequest::ReEnableMatchWithDriverUrl { .. } => {
"re_enable_match_with_driver_url"
}
DriverIndexRequest::_UnknownMethod {
method_type: fidl::MethodType::OneWay, ..
} => "unknown one-way method",
DriverIndexRequest::_UnknownMethod {
method_type: fidl::MethodType::TwoWay, ..
} => "unknown two-way method",
}
}
}
#[derive(Debug, Clone)]
pub struct DriverIndexControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for DriverIndexControlHandle {
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 DriverIndexControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverIndexDisableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop<DriverIndexControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverIndexDisableMatchWithDriverUrlResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverIndexDisableMatchWithDriverUrlResponder {
type ControlHandle = DriverIndexControlHandle;
fn control_handle(&self) -> &DriverIndexControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverIndexDisableMatchWithDriverUrlResponder {
pub fn send(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
let _result = self.send_raw();
self.drop_without_shutdown();
_result
}
fn send_raw(&self) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
fidl::encoding::Flexible::new(()),
self.tx_id,
0x5ab4b815cc8995b0,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverIndexReEnableMatchWithDriverUrlResponder {
control_handle: std::mem::ManuallyDrop<DriverIndexControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverIndexReEnableMatchWithDriverUrlResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverIndexReEnableMatchWithDriverUrlResponder {
type ControlHandle = DriverIndexControlHandle;
fn control_handle(&self) -> &DriverIndexControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverIndexReEnableMatchWithDriverUrlResponder {
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::FlexibleResultType<
fidl::encoding::EmptyStruct,
i32,
>>(
fidl::encoding::FlexibleResult::new(result),
self.tx_id,
0x102717ab190e9c7,
fidl::encoding::DynamicFlags::FLEXIBLE,
)
}
}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DriverInfoIteratorMarker;
impl fidl::endpoints::ProtocolMarker for DriverInfoIteratorMarker {
type Proxy = DriverInfoIteratorProxy;
type RequestStream = DriverInfoIteratorRequestStream;
const DEBUG_NAME: &'static str = "(anonymous) DriverInfoIterator";
}
pub trait DriverInfoIteratorProxyInterface: Send + Sync {
type GetNextResponseFut: std::future::Future<Output = Result<Vec<DriverInfo>, fidl::Error>>
+ Send;
fn r#get_next(&self) -> Self::GetNextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DriverInfoIteratorSynchronousProxy {
client: fidl::client::sync::Client,
}
#[cfg(target_os = "fuchsia")]
impl DriverInfoIteratorSynchronousProxy {
pub fn new(channel: fidl::Channel) -> Self {
let protocol_name =
<DriverInfoIteratorMarker 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<DriverInfoIteratorEvent, fidl::Error> {
DriverInfoIteratorEvent::decode(self.client.wait_for_event(deadline)?)
}
pub fn r#get_next(&self, ___deadline: zx::Time) -> Result<Vec<DriverInfo>, fidl::Error> {
let _response = self
.client
.send_query::<fidl::encoding::EmptyPayload, DriverInfoIteratorGetNextResponse>(
(),
0x2c394711c6784952,
fidl::encoding::DynamicFlags::empty(),
___deadline,
)?;
Ok(_response.drivers)
}
}
#[derive(Debug, Clone)]
pub struct DriverInfoIteratorProxy {
client: fidl::client::Client,
}
impl fidl::endpoints::Proxy for DriverInfoIteratorProxy {
type Protocol = DriverInfoIteratorMarker;
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 DriverInfoIteratorProxy {
pub fn new(channel: fidl::AsyncChannel) -> Self {
let protocol_name =
<DriverInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
Self { client: fidl::client::Client::new(channel, protocol_name) }
}
pub fn take_event_stream(&self) -> DriverInfoIteratorEventStream {
DriverInfoIteratorEventStream { event_receiver: self.client.take_event_receiver() }
}
pub fn r#get_next(&self) -> fidl::client::QueryResponseFut<Vec<DriverInfo>> {
DriverInfoIteratorProxyInterface::r#get_next(self)
}
}
impl DriverInfoIteratorProxyInterface for DriverInfoIteratorProxy {
type GetNextResponseFut = fidl::client::QueryResponseFut<Vec<DriverInfo>>;
fn r#get_next(&self) -> Self::GetNextResponseFut {
fn _decode(
mut _buf: Result<fidl::MessageBufEtc, fidl::Error>,
) -> Result<Vec<DriverInfo>, fidl::Error> {
let _response = fidl::client::decode_transaction_body::<
DriverInfoIteratorGetNextResponse,
0x2c394711c6784952,
>(_buf?)?;
Ok(_response.drivers)
}
self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<DriverInfo>>(
(),
0x2c394711c6784952,
fidl::encoding::DynamicFlags::empty(),
_decode,
)
}
}
pub struct DriverInfoIteratorEventStream {
event_receiver: fidl::client::EventReceiver,
}
impl std::marker::Unpin for DriverInfoIteratorEventStream {}
impl futures::stream::FusedStream for DriverInfoIteratorEventStream {
fn is_terminated(&self) -> bool {
self.event_receiver.is_terminated()
}
}
impl futures::Stream for DriverInfoIteratorEventStream {
type Item = Result<DriverInfoIteratorEvent, 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(DriverInfoIteratorEvent::decode(buf))),
None => std::task::Poll::Ready(None),
}
}
}
#[derive(Debug)]
pub enum DriverInfoIteratorEvent {}
impl DriverInfoIteratorEvent {
fn decode(mut buf: fidl::MessageBufEtc) -> Result<DriverInfoIteratorEvent, 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:
<DriverInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}
}
}
pub struct DriverInfoIteratorRequestStream {
inner: std::sync::Arc<fidl::ServeInner>,
is_terminated: bool,
}
impl std::marker::Unpin for DriverInfoIteratorRequestStream {}
impl futures::stream::FusedStream for DriverInfoIteratorRequestStream {
fn is_terminated(&self) -> bool {
self.is_terminated
}
}
impl fidl::endpoints::RequestStream for DriverInfoIteratorRequestStream {
type Protocol = DriverInfoIteratorMarker;
type ControlHandle = DriverInfoIteratorControlHandle;
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 {
DriverInfoIteratorControlHandle { 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 DriverInfoIteratorRequestStream {
type Item = Result<DriverInfoIteratorRequest, 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 DriverInfoIteratorRequestStream 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 {
0x2c394711c6784952 => {
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 =
DriverInfoIteratorControlHandle { inner: this.inner.clone() };
Ok(DriverInfoIteratorRequest::GetNext {
responder: DriverInfoIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop::new(control_handle),
tx_id: header.tx_id,
},
})
}
_ => Err(fidl::Error::UnknownOrdinal {
ordinal: header.ordinal,
protocol_name:
<DriverInfoIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
}),
}))
})
}
}
#[derive(Debug)]
pub enum DriverInfoIteratorRequest {
GetNext { responder: DriverInfoIteratorGetNextResponder },
}
impl DriverInfoIteratorRequest {
#[allow(irrefutable_let_patterns)]
pub fn into_get_next(self) -> Option<(DriverInfoIteratorGetNextResponder)> {
if let DriverInfoIteratorRequest::GetNext { responder } = self {
Some((responder))
} else {
None
}
}
pub fn method_name(&self) -> &'static str {
match *self {
DriverInfoIteratorRequest::GetNext { .. } => "get_next",
}
}
}
#[derive(Debug, Clone)]
pub struct DriverInfoIteratorControlHandle {
inner: std::sync::Arc<fidl::ServeInner>,
}
impl fidl::endpoints::ControlHandle for DriverInfoIteratorControlHandle {
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 DriverInfoIteratorControlHandle {}
#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DriverInfoIteratorGetNextResponder {
control_handle: std::mem::ManuallyDrop<DriverInfoIteratorControlHandle>,
tx_id: u32,
}
impl std::ops::Drop for DriverInfoIteratorGetNextResponder {
fn drop(&mut self) {
self.control_handle.shutdown();
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
}
}
impl fidl::endpoints::Responder for DriverInfoIteratorGetNextResponder {
type ControlHandle = DriverInfoIteratorControlHandle;
fn control_handle(&self) -> &DriverInfoIteratorControlHandle {
&self.control_handle
}
fn drop_without_shutdown(mut self) {
unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
std::mem::forget(self);
}
}
impl DriverInfoIteratorGetNextResponder {
pub fn send(self, mut drivers: &[DriverInfo]) -> Result<(), fidl::Error> {
let _result = self.send_raw(drivers);
if _result.is_err() {
self.control_handle.shutdown();
}
self.drop_without_shutdown();
_result
}
pub fn send_no_shutdown_on_err(self, mut drivers: &[DriverInfo]) -> Result<(), fidl::Error> {
let _result = self.send_raw(drivers);
self.drop_without_shutdown();
_result
}
fn send_raw(&self, mut drivers: &[DriverInfo]) -> Result<(), fidl::Error> {
self.control_handle.inner.send::<DriverInfoIteratorGetNextResponse>(
(drivers,),
self.tx_id,
0x2c394711c6784952,
fidl::encoding::DynamicFlags::empty(),
)
}
}
mod internal {
use super::*;
unsafe impl fidl::encoding::TypeMarker for DeviceFlags {
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 DeviceFlags {
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 DeviceFlags {
#[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 DeviceFlags {
#[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 RematchFlags {
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 RematchFlags {
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 RematchFlags {
#[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.bits, offset);
Ok(())
}
}
impl fidl::encoding::Decode<Self> for RematchFlags {
#[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_allow_unknown(prim);
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeInfoIteratorGetNextResponse {
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 CompositeInfoIteratorGetNextResponse {
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<CompositeInfoIteratorGetNextResponse>
for &CompositeInfoIteratorGetNextResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeInfoIteratorGetNextResponse>(offset);
fidl::encoding::Encode::<CompositeInfoIteratorGetNextResponse>::encode(
(
<fidl::encoding::UnboundedVector<CompositeInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.composites),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<CompositeInfo>>>
fidl::encoding::Encode<CompositeInfoIteratorGetNextResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeInfoIteratorGetNextResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeInfoIteratorGetNextResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { composites: fidl::new_empty!(fidl::encoding::UnboundedVector<CompositeInfo>) }
}
#[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<CompositeInfo>,
&mut self.composites,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecIteratorGetNextResponse {
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 CompositeNodeSpecIteratorGetNextResponse {
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<CompositeNodeSpecIteratorGetNextResponse>
for &CompositeNodeSpecIteratorGetNextResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeNodeSpecIteratorGetNextResponse>(offset);
fidl::encoding::Encode::<CompositeNodeSpecIteratorGetNextResponse>::encode(
(
<fidl::encoding::UnboundedVector<CompositeNodeSpecInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.specs),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<CompositeNodeSpecInfo>>>
fidl::encoding::Encode<CompositeNodeSpecIteratorGetNextResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeNodeSpecIteratorGetNextResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeNodeSpecIteratorGetNextResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { specs: fidl::new_empty!(fidl::encoding::UnboundedVector<CompositeNodeSpecInfo>) }
}
#[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<CompositeNodeSpecInfo>,
&mut self.specs,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceInfoIteratorGetNextResponse {
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 DeviceInfoIteratorGetNextResponse {
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<DeviceInfoIteratorGetNextResponse>
for &DeviceInfoIteratorGetNextResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceInfoIteratorGetNextResponse>(offset);
fidl::encoding::Encode::<DeviceInfoIteratorGetNextResponse>::encode(
(
<fidl::encoding::UnboundedVector<DeviceInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.drivers),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<DeviceInfo>>>
fidl::encoding::Encode<DeviceInfoIteratorGetNextResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceInfoIteratorGetNextResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceInfoIteratorGetNextResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { drivers: fidl::new_empty!(fidl::encoding::UnboundedVector<DeviceInfo>) }
}
#[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<DeviceInfo>,
&mut self.drivers,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentAddTestNodeRequest {
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 DriverDevelopmentAddTestNodeRequest {
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<DriverDevelopmentAddTestNodeRequest>
for &DriverDevelopmentAddTestNodeRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentAddTestNodeRequest>(offset);
fidl::encoding::Encode::<DriverDevelopmentAddTestNodeRequest>::encode(
(<TestNodeAddArgs as fidl::encoding::ValueTypeMarker>::borrow(&self.args),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<TestNodeAddArgs>>
fidl::encoding::Encode<DriverDevelopmentAddTestNodeRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentAddTestNodeRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentAddTestNodeRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { args: fidl::new_empty!(TestNodeAddArgs) }
}
#[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!(TestNodeAddArgs, &mut self.args, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentGetCompositeInfoRequest {
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 DriverDevelopmentGetCompositeInfoRequest {
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<DriverDevelopmentGetCompositeInfoRequest>
for &mut DriverDevelopmentGetCompositeInfoRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentGetCompositeInfoRequest>(offset);
fidl::encoding::Encode::<DriverDevelopmentGetCompositeInfoRequest>::encode(
(
<fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
&mut self.iterator
),
),
encoder,
offset,
_depth,
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>>,
>,
> fidl::encoding::Encode<DriverDevelopmentGetCompositeInfoRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentGetCompositeInfoRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentGetCompositeInfoRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
iterator: fidl::new_empty!(
fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<CompositeInfoIteratorMarker>,
>
),
}
}
#[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<CompositeInfoIteratorMarker>>,
&mut self.iterator,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentGetDeviceInfoRequest {
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::ResourceTypeMarker for DriverDevelopmentGetDeviceInfoRequest {
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<DriverDevelopmentGetDeviceInfoRequest>
for &mut DriverDevelopmentGetDeviceInfoRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentGetDeviceInfoRequest>(offset);
fidl::encoding::Encode::<DriverDevelopmentGetDeviceInfoRequest>::encode(
(
<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.device_filter),
<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.iterator),
<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.exact_match),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
>,
T1: fidl::encoding::Encode<
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>>,
>,
T2: fidl::encoding::Encode<bool>,
> fidl::encoding::Encode<DriverDevelopmentGetDeviceInfoRequest> 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::<DriverDevelopmentGetDeviceInfoRequest>(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 + 20, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentGetDeviceInfoRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
device_filter: fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>
),
iterator: fidl::new_empty!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>>
),
exact_match: 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(16) };
let padval = unsafe { (ptr as *const u64).read_unaligned() };
let maskedval = padval & 0xffffff0000000000u64;
if (maskedval != 0) {
return Err(fidl::Error::NonZeroPadding {
padding_start: offset
+ 16
+ ((0xffffff0000000000u64 as u64).trailing_zeros() / 8) as usize,
});
}
fidl::decode!(
fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
&mut self.device_filter,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DeviceInfoIteratorMarker>>,
&mut self.iterator,
decoder,
offset + 16,
_depth
)?;
fidl::decode!(bool, &mut self.exact_match, decoder, offset + 20, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentRemoveTestNodeRequest {
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 DriverDevelopmentRemoveTestNodeRequest {
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<DriverDevelopmentRemoveTestNodeRequest>
for &DriverDevelopmentRemoveTestNodeRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentRemoveTestNodeRequest>(offset);
fidl::encoding::Encode::<DriverDevelopmentRemoveTestNodeRequest>::encode(
(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(
&self.name,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>>
fidl::encoding::Encode<DriverDevelopmentRemoveTestNodeRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentRemoveTestNodeRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentRemoveTestNodeRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { name: 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.name,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentRestartDriverHostsRequest {
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 DriverDevelopmentRestartDriverHostsRequest {
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<DriverDevelopmentRestartDriverHostsRequest>
for &DriverDevelopmentRestartDriverHostsRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentRestartDriverHostsRequest>(offset);
fidl::encoding::Encode::<DriverDevelopmentRestartDriverHostsRequest>::encode(
(
<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_path),
<RematchFlags as fidl::encoding::ValueTypeMarker>::borrow(&self.rematch_flags),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>>,
T1: fidl::encoding::Encode<RematchFlags>,
> fidl::encoding::Encode<DriverDevelopmentRestartDriverHostsRequest> 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::<DriverDevelopmentRestartDriverHostsRequest>(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)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentRestartDriverHostsRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
driver_path: fidl::new_empty!(fidl::encoding::BoundedString<1024>),
rematch_flags: fidl::new_empty!(RematchFlags),
}
}
#[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!(RematchFlags, &mut self.rematch_flags, decoder, offset + 16, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentBindAllUnboundNodesResponse {
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 DriverDevelopmentBindAllUnboundNodesResponse {
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<DriverDevelopmentBindAllUnboundNodesResponse>
for &DriverDevelopmentBindAllUnboundNodesResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentBindAllUnboundNodesResponse>(offset);
fidl::encoding::Encode::<DriverDevelopmentBindAllUnboundNodesResponse>::encode(
(
<fidl::encoding::Vector<NodeBindingInfo, 10> as fidl::encoding::ValueTypeMarker>::borrow(&self.binding_result),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::Vector<NodeBindingInfo, 10>>>
fidl::encoding::Encode<DriverDevelopmentBindAllUnboundNodesResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentBindAllUnboundNodesResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentBindAllUnboundNodesResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { binding_result: fidl::new_empty!(fidl::encoding::Vector<NodeBindingInfo, 10>) }
}
#[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<NodeBindingInfo, 10>, &mut self.binding_result, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentIsDfv2Response {
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 DriverDevelopmentIsDfv2Response {
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<DriverDevelopmentIsDfv2Response>
for &DriverDevelopmentIsDfv2Response
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentIsDfv2Response>(offset);
fidl::encoding::Encode::<DriverDevelopmentIsDfv2Response>::encode(
(<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.response),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<bool>>
fidl::encoding::Encode<DriverDevelopmentIsDfv2Response> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentIsDfv2Response>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentIsDfv2Response {
#[inline(always)]
fn new_empty() -> Self {
Self { response: 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.response, decoder, offset + 0, _depth)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverDevelopmentRestartDriverHostsResponse {
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 DriverDevelopmentRestartDriverHostsResponse {
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<DriverDevelopmentRestartDriverHostsResponse>
for &DriverDevelopmentRestartDriverHostsResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentRestartDriverHostsResponse>(offset);
unsafe {
let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
(buf_ptr as *mut DriverDevelopmentRestartDriverHostsResponse).write_unaligned(
(self as *const DriverDevelopmentRestartDriverHostsResponse).read(),
);
}
Ok(())
}
}
unsafe impl<T0: fidl::encoding::Encode<u32>>
fidl::encoding::Encode<DriverDevelopmentRestartDriverHostsResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverDevelopmentRestartDriverHostsResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverDevelopmentRestartDriverHostsResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { count: 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 DriverIndexDisableMatchWithDriverUrlRequest {
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 DriverIndexDisableMatchWithDriverUrlRequest {
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<DriverIndexDisableMatchWithDriverUrlRequest>
for &DriverIndexDisableMatchWithDriverUrlRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverIndexDisableMatchWithDriverUrlRequest>(offset);
fidl::encoding::Encode::<DriverIndexDisableMatchWithDriverUrlRequest>::encode(
(<fidl_fuchsia_pkg::PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(
&self.driver_url,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl_fuchsia_pkg::PackageUrl>>
fidl::encoding::Encode<DriverIndexDisableMatchWithDriverUrlRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverIndexDisableMatchWithDriverUrlRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverIndexDisableMatchWithDriverUrlRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { driver_url: fidl::new_empty!(fidl_fuchsia_pkg::PackageUrl) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl_fuchsia_pkg::PackageUrl,
&mut self.driver_url,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverIndexGetCompositeNodeSpecsRequest {
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::ResourceTypeMarker for DriverIndexGetCompositeNodeSpecsRequest {
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<DriverIndexGetCompositeNodeSpecsRequest>
for &mut DriverIndexGetCompositeNodeSpecsRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverIndexGetCompositeNodeSpecsRequest>(offset);
fidl::encoding::Encode::<DriverIndexGetCompositeNodeSpecsRequest>::encode(
(
<fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.name_filter),
<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.iterator),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::UnboundedString>>,
T1: fidl::encoding::Encode<
fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
>,
>,
> fidl::encoding::Encode<DriverIndexGetCompositeNodeSpecsRequest> 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::<DriverIndexGetCompositeNodeSpecsRequest>(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)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverIndexGetCompositeNodeSpecsRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
name_filter: fidl::new_empty!(
fidl::encoding::Optional<fidl::encoding::UnboundedString>
),
iterator: fidl::new_empty!(
fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
>
),
}
}
#[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::Optional<fidl::encoding::UnboundedString>,
&mut self.name_filter,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::Endpoint<
fidl::endpoints::ServerEnd<CompositeNodeSpecIteratorMarker>,
>,
&mut self.iterator,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverIndexGetDriverInfoRequest {
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::ResourceTypeMarker for DriverIndexGetDriverInfoRequest {
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<DriverIndexGetDriverInfoRequest>
for &mut DriverIndexGetDriverInfoRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverIndexGetDriverInfoRequest>(offset);
fidl::encoding::Encode::<DriverIndexGetDriverInfoRequest>::encode(
(
<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.driver_filter),
<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.iterator),
),
encoder, offset, _depth
)
}
}
unsafe impl<
T0: fidl::encoding::Encode<
fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
>,
T1: fidl::encoding::Encode<
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>>,
>,
> fidl::encoding::Encode<DriverIndexGetDriverInfoRequest> 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::<DriverIndexGetDriverInfoRequest>(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)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverIndexGetDriverInfoRequest {
#[inline(always)]
fn new_empty() -> Self {
Self {
driver_filter: fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>
),
iterator: fidl::new_empty!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>>
),
}
}
#[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::UnboundedVector<fidl::encoding::UnboundedString>,
&mut self.driver_filter,
decoder,
offset + 0,
_depth
)?;
fidl::decode!(
fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<DriverInfoIteratorMarker>>,
&mut self.iterator,
decoder,
offset + 16,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverIndexReEnableMatchWithDriverUrlRequest {
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 DriverIndexReEnableMatchWithDriverUrlRequest {
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<DriverIndexReEnableMatchWithDriverUrlRequest>
for &DriverIndexReEnableMatchWithDriverUrlRequest
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverIndexReEnableMatchWithDriverUrlRequest>(offset);
fidl::encoding::Encode::<DriverIndexReEnableMatchWithDriverUrlRequest>::encode(
(<fidl_fuchsia_pkg::PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(
&self.driver_url,
),),
encoder,
offset,
_depth,
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl_fuchsia_pkg::PackageUrl>>
fidl::encoding::Encode<DriverIndexReEnableMatchWithDriverUrlRequest> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverIndexReEnableMatchWithDriverUrlRequest>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverIndexReEnableMatchWithDriverUrlRequest {
#[inline(always)]
fn new_empty() -> Self {
Self { driver_url: fidl::new_empty!(fidl_fuchsia_pkg::PackageUrl) }
}
#[inline]
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
fidl::decode!(
fidl_fuchsia_pkg::PackageUrl,
&mut self.driver_url,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
unsafe impl fidl::encoding::TypeMarker for DriverInfoIteratorGetNextResponse {
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 DriverInfoIteratorGetNextResponse {
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<DriverInfoIteratorGetNextResponse>
for &DriverInfoIteratorGetNextResponse
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
_depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverInfoIteratorGetNextResponse>(offset);
fidl::encoding::Encode::<DriverInfoIteratorGetNextResponse>::encode(
(
<fidl::encoding::UnboundedVector<DriverInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.drivers),
),
encoder, offset, _depth
)
}
}
unsafe impl<T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<DriverInfo>>>
fidl::encoding::Encode<DriverInfoIteratorGetNextResponse> for (T0,)
{
#[inline]
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverInfoIteratorGetNextResponse>(offset);
self.0.encode(encoder, offset + 0, depth)?;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverInfoIteratorGetNextResponse {
#[inline(always)]
fn new_empty() -> Self {
Self { drivers: fidl::new_empty!(fidl::encoding::UnboundedVector<DriverInfo>) }
}
#[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<DriverInfo>,
&mut self.drivers,
decoder,
offset + 0,
_depth
)?;
Ok(())
}
}
impl CompositeInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.node_info {
return 5;
}
if let Some(_) = self.primary_index {
return 4;
}
if let Some(_) = self.topological_path {
return 3;
}
if let Some(_) = self.driver {
return 2;
}
if let Some(_) = self.name {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeInfo {
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 CompositeInfo {
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<CompositeInfo> for &CompositeInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.name.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.driver.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.topological_path.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.primary_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<CompositeNodeInfo>(
self.node_info
.as_ref()
.map(<CompositeNodeInfo as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.driver
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.topological_path
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.primary_index.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<CompositeNodeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.node_info.get_or_insert_with(|| fidl::new_empty!(CompositeNodeInfo));
fidl::decode!(CompositeNodeInfo, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl CompositeNodeSpecInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.parents {
return 5;
}
if let Some(_) = self.parent_names {
return 4;
}
if let Some(_) = self.primary_index {
return 3;
}
if let Some(_) = self.driver {
return 2;
}
if let Some(_) = self.name {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecInfo {
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 CompositeNodeSpecInfo {
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<CompositeNodeSpecInfo> for &CompositeNodeSpecInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeNodeSpecInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.name.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.driver.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.primary_index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>>(
self.parent_names.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>>(
self.parents.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeNodeSpecInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.driver
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.primary_index.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<
fidl::encoding::UnboundedString,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.parent_names.get_or_insert_with(|| {
fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>
)
});
fidl::decode!(
fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<
fidl_fuchsia_driver_framework::ParentSpec,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.parents.get_or_insert_with(|| {
fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>
)
});
fidl::decode!(
fidl::encoding::UnboundedVector<fidl_fuchsia_driver_framework::ParentSpec>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl CompositeParentNodeInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.device {
return 2;
}
if let Some(_) = self.name {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for CompositeParentNodeInfo {
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 CompositeParentNodeInfo {
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<CompositeParentNodeInfo> for &CompositeParentNodeInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<CompositeParentNodeInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.name.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.device.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for CompositeParentNodeInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.device
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl DeviceInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.protocol_name {
return 14;
}
if let Some(_) = self.protocol_id {
return 13;
}
if let Some(_) = self.offer_list {
return 12;
}
if let Some(_) = self.node_property_list {
return 11;
}
if let Some(_) = self.moniker {
return 10;
}
if let Some(_) = self.flags {
return 9;
}
if let Some(_) = self.property_list {
return 8;
}
if let Some(_) = self.bound_driver_url {
return 7;
}
if let Some(_) = self.bound_driver_libname {
return 6;
}
if let Some(_) = self.topological_path {
return 5;
}
if let Some(_) = self.driver_host_koid {
return 4;
}
if let Some(_) = self.child_ids {
return 3;
}
if let Some(_) = self.parent_ids {
return 2;
}
if let Some(_) = self.id {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for DeviceInfo {
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 DeviceInfo {
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<DeviceInfo> for &DeviceInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DeviceInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u64>(
self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>>(
self.parent_ids.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>>(
self.child_ids.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u64>(
self.driver_host_koid
.as_ref()
.map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>>(
self.topological_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 6 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (6 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>>(
self.bound_driver_libname.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 7 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (7 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>>(
self.bound_driver_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 8 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (8 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_device_manager::DevicePropertyList>(
self.property_list.as_ref().map(<fidl_fuchsia_device_manager::DevicePropertyList as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 9 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (9 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<DeviceFlags>(
self.flags.as_ref().map(<DeviceFlags as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 10 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (10 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>>(
self.moniker.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 11 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (11 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64>>(
self.node_property_list.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 12 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (12 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Offer>>(
self.offer_list.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Offer> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 13 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (13 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<u32>(
self.protocol_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 14 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (14 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.protocol_name.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DeviceInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64));
fidl::decode!(u64, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.parent_ids
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedVector<u64>));
fidl::decode!(
fidl::encoding::UnboundedVector<u64>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.child_ids
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedVector<u64>));
fidl::decode!(
fidl::encoding::UnboundedVector<u64>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.driver_host_koid.get_or_insert_with(|| fidl::new_empty!(u64));
fidl::decode!(u64, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.topological_path
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<1024>));
fidl::decode!(
fidl::encoding::BoundedString<1024>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 6 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.bound_driver_libname
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<1024>));
fidl::decode!(
fidl::encoding::BoundedString<1024>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 7 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.bound_driver_url
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<4096>));
fidl::decode!(
fidl::encoding::BoundedString<4096>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 8 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl_fuchsia_device_manager::DevicePropertyList as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.property_list.get_or_insert_with(|| {
fidl::new_empty!(fidl_fuchsia_device_manager::DevicePropertyList)
});
fidl::decode!(
fidl_fuchsia_device_manager::DevicePropertyList,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 9 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<DeviceFlags as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.flags.get_or_insert_with(|| fidl::new_empty!(DeviceFlags));
fidl::decode!(DeviceFlags, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 10 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.moniker
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<1024>));
fidl::decode!(
fidl::encoding::BoundedString<1024>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 11 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<
fidl_fuchsia_driver_framework::NodeProperty,
64,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.node_property_list.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64>));
fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64>, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 12 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<
fidl_fuchsia_component_decl::Offer,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.offer_list.get_or_insert_with(|| {
fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Offer>
)
});
fidl::decode!(
fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl::Offer>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 13 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.protocol_id.get_or_insert_with(|| fidl::new_empty!(u32));
fidl::decode!(u32, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 14 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.protocol_name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl DriverInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.device_categories {
return 7;
}
if let Some(_) = self.package_hash {
return 6;
}
if let Some(_) = self.package_type {
return 5;
}
if let Some(_) = self.bind_rules {
return 4;
}
if let Some(_) = self.url {
return 3;
}
if let Some(_) = self.name {
return 2;
}
if let Some(_) = self.libname {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for DriverInfo {
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 DriverInfo {
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<DriverInfo> for &DriverInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<DriverInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>>(
self.libname.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.name.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>>(
self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<BindRulesBytecode>(
self.bind_rules
.as_ref()
.map(<BindRulesBytecode as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 5 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (5 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_driver_index::DriverPackageType>(
self.package_type.as_ref().map(<fidl_fuchsia_driver_index::DriverPackageType as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 6 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (6 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_pkg::BlobId>(
self.package_hash
.as_ref()
.map(<fidl_fuchsia_pkg::BlobId as fidl::encoding::ValueTypeMarker>::borrow),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 7 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (7 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_driver_index::DeviceCategory>>(
self.device_categories.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_driver_index::DeviceCategory> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for DriverInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.libname
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<1024>));
fidl::decode!(
fidl::encoding::BoundedString<1024>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.url
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<4096>));
fidl::decode!(
fidl::encoding::BoundedString<4096>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<BindRulesBytecode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.bind_rules.get_or_insert_with(|| fidl::new_empty!(BindRulesBytecode));
fidl::decode!(BindRulesBytecode, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 5 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl_fuchsia_driver_index::DriverPackageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.package_type.get_or_insert_with(|| {
fidl::new_empty!(fidl_fuchsia_driver_index::DriverPackageType)
});
fidl::decode!(
fidl_fuchsia_driver_index::DriverPackageType,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 6 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl_fuchsia_pkg::BlobId as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.package_hash
.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_pkg::BlobId));
fidl::decode!(
fidl_fuchsia_pkg::BlobId,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 7 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<
fidl_fuchsia_driver_index::DeviceCategory,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.device_categories.get_or_insert_with(|| {
fidl::new_empty!(
fidl::encoding::UnboundedVector<fidl_fuchsia_driver_index::DeviceCategory>
)
});
fidl::decode!(
fidl::encoding::UnboundedVector<fidl_fuchsia_driver_index::DeviceCategory>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl LegacyCompositeFragmentInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.device {
return 3;
}
if let Some(_) = self.bind_rules {
return 2;
}
if let Some(_) = self.name {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for LegacyCompositeFragmentInfo {
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 LegacyCompositeFragmentInfo {
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<LegacyCompositeFragmentInfo> for &LegacyCompositeFragmentInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<LegacyCompositeFragmentInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.name.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_device_manager::BindInstruction, 256>>(
self.bind_rules.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_device_manager::BindInstruction, 256> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString>(
self.device.as_ref().map(
<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for LegacyCompositeFragmentInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<
fidl_fuchsia_device_manager::BindInstruction,
256,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.bind_rules.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_device_manager::BindInstruction, 256>));
fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_device_manager::BindInstruction, 256>, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size =
<fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
decoder.context,
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.device
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString));
fidl::decode!(
fidl::encoding::UnboundedString,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl LegacyCompositeNodeInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.properties {
return 2;
}
if let Some(_) = self.fragments {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for LegacyCompositeNodeInfo {
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 LegacyCompositeNodeInfo {
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<LegacyCompositeNodeInfo> for &LegacyCompositeNodeInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<LegacyCompositeNodeInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<LegacyCompositeFragmentInfo>>(
self.fragments.as_ref().map(<fidl::encoding::UnboundedVector<LegacyCompositeFragmentInfo> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64>>(
self.properties.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for LegacyCompositeNodeInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<
LegacyCompositeFragmentInfo,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.fragments.get_or_insert_with(|| {
fidl::new_empty!(fidl::encoding::UnboundedVector<LegacyCompositeFragmentInfo>)
});
fidl::decode!(
fidl::encoding::UnboundedVector<LegacyCompositeFragmentInfo>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<
fidl_fuchsia_driver_framework::NodeProperty,
64,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.properties.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64>));
fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64>, val_ref, decoder, inner_offset, inner_depth)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl NodeBindingInfo {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.legacy_composites {
return 4;
}
if let Some(_) = self.composite_specs {
return 3;
}
if let Some(_) = self.driver_url {
return 2;
}
if let Some(_) = self.node_name {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for NodeBindingInfo {
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 NodeBindingInfo {
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<NodeBindingInfo> for &NodeBindingInfo {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<NodeBindingInfo>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>>(
self.node_name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>>(
self.driver_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 3 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (3 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<
fidl::encoding::UnboundedVector<
fidl_fuchsia_driver_index::MatchedCompositeNodeSpecInfo,
>,
>(
self.composite_specs.as_ref().map(
<fidl::encoding::UnboundedVector<
fidl_fuchsia_driver_index::MatchedCompositeNodeSpecInfo,
> as fidl::encoding::ValueTypeMarker>::borrow,
),
encoder,
offset + cur_offset,
depth,
)?;
_prev_end_offset = cur_offset + envelope_size;
if 4 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (4 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<CompositeInfo>>(
self.legacy_composites.as_ref().map(<fidl::encoding::UnboundedVector<CompositeInfo> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for NodeBindingInfo {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.node_name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<1024>));
fidl::decode!(
fidl::encoding::BoundedString<1024>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.driver_url
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<4096>));
fidl::decode!(
fidl::encoding::BoundedString<4096>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 3 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<
fidl_fuchsia_driver_index::MatchedCompositeNodeSpecInfo,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.composite_specs.get_or_insert_with(|| {
fidl::new_empty!(
fidl::encoding::UnboundedVector<
fidl_fuchsia_driver_index::MatchedCompositeNodeSpecInfo,
>
)
});
fidl::decode!(
fidl::encoding::UnboundedVector<
fidl_fuchsia_driver_index::MatchedCompositeNodeSpecInfo,
>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 4 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::UnboundedVector<CompositeInfo> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self.legacy_composites.get_or_insert_with(|| {
fidl::new_empty!(fidl::encoding::UnboundedVector<CompositeInfo>)
});
fidl::decode!(
fidl::encoding::UnboundedVector<CompositeInfo>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
while next_offset < end_offset {
_next_ordinal_to_read += 1;
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
next_offset += envelope_size;
}
Ok(())
}
}
impl TestNodeAddArgs {
#[inline(always)]
fn max_ordinal_present(&self) -> u64 {
if let Some(_) = self.properties {
return 2;
}
if let Some(_) = self.name {
return 1;
}
0
}
}
unsafe impl fidl::encoding::TypeMarker for TestNodeAddArgs {
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 TestNodeAddArgs {
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<TestNodeAddArgs> for &TestNodeAddArgs {
unsafe fn encode(
self,
encoder: &mut fidl::encoding::Encoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
encoder.debug_check_bounds::<TestNodeAddArgs>(offset);
let max_ordinal: u64 = self.max_ordinal_present();
encoder.write_num(max_ordinal, offset);
encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
if max_ordinal == 0 {
return Ok(());
}
depth.increment()?;
let envelope_size = 8;
let bytes_len = max_ordinal as usize * envelope_size;
#[allow(unused_variables)]
let offset = encoder.out_of_line_offset(bytes_len);
let mut _prev_end_offset: usize = 0;
if 1 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (1 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>>(
self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
if 2 > max_ordinal {
return Ok(());
}
let cur_offset: usize = (2 - 1) * envelope_size;
encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64>>(
self.properties.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow),
encoder, offset + cur_offset, depth
)?;
_prev_end_offset = cur_offset + envelope_size;
Ok(())
}
}
impl fidl::encoding::Decode<Self> for TestNodeAddArgs {
#[inline(always)]
fn new_empty() -> Self {
Self::default()
}
unsafe fn decode(
&mut self,
decoder: &mut fidl::encoding::Decoder<'_>,
offset: usize,
mut depth: fidl::encoding::Depth,
) -> fidl::Result<()> {
decoder.debug_check_bounds::<Self>(offset);
let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
None => return Err(fidl::Error::NotNullable),
Some(len) => len,
};
depth.increment()?;
let envelope_size = 8;
let bytes_len = len * envelope_size;
let offset = decoder.out_of_line_offset(bytes_len)?;
let mut _next_ordinal_to_read = 0;
let mut next_offset = offset;
let end_offset = offset + bytes_len;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 1 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref = self
.name
.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<1024>));
fidl::decode!(
fidl::encoding::BoundedString<1024>,
val_ref,
decoder,
inner_offset,
inner_depth
)?;
if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
{
return Err(fidl::Error::InvalidNumBytesInEnvelope);
}
if handles_before != decoder.remaining_handles() + (num_handles as usize) {
return Err(fidl::Error::InvalidNumHandlesInEnvelope);
}
}
next_offset += envelope_size;
_next_ordinal_to_read += 1;
if next_offset >= end_offset {
return Ok(());
}
while _next_ordinal_to_read < 2 {
fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
_next_ordinal_to_read += 1;
next_offset += envelope_size;
}
let next_out_of_line = decoder.next_out_of_line();
let handles_before = decoder.remaining_handles();
if let Some((inlined, num_bytes, num_handles)) =
fidl::encoding::decode_envelope_header(decoder, next_offset)?
{
let member_inline_size = <fidl::encoding::Vector<
fidl_fuchsia_driver_framework::NodeProperty,
64,
> as fidl::encoding::TypeMarker>::inline_size(
decoder.context
);
if inlined != (member_inline_size <= 4) {
return Err(fidl::Error::InvalidInlineBitInEnvelope);
}
let inner_offset;
let mut inner_depth = depth.clone();
if inlined {
decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
inner_offset = next_offset;
} else {
inner_offset = decoder.out_of_line_offset(member_inline_size)?;
inner_depth.increment()?;
}
let val_ref =
self.properties.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_driver_framework::NodeProperty,