fidl_fuchsia_bluetooth_avdtp_test_common/
fidl_fuchsia_bluetooth_avdtp_test_common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// Maximum number of peers that can be connected to a node.
12/// (Core Spec 5.0, Vol 2, Part B, Section 1)
13pub const MAX_PICONET_SIZE: u64 = 8;
14
15/// Represents the return status of a [`fuchsia.bluetooth.avdtp.Peer`] method
16#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
17#[repr(u32)]
18pub enum PeerError {
19    /// Failure reason is not known
20    UnknownFailure = 1,
21    /// The peer is unable to perform the request
22    ProtocolError = 2,
23}
24
25impl PeerError {
26    #[inline]
27    pub fn from_primitive(prim: u32) -> Option<Self> {
28        match prim {
29            1 => Some(Self::UnknownFailure),
30            2 => Some(Self::ProtocolError),
31            _ => None,
32        }
33    }
34
35    #[inline]
36    pub const fn into_primitive(self) -> u32 {
37        self as u32
38    }
39
40    #[deprecated = "Strict enums should not use `is_unknown`"]
41    #[inline]
42    pub fn is_unknown(&self) -> bool {
43        false
44    }
45}
46
47#[derive(Clone, Debug, PartialEq)]
48pub struct PeerManagerConnectedPeersResponse {
49    pub peer_ids: Vec<fidl_fuchsia_bluetooth::PeerId>,
50}
51
52impl fidl::Persistable for PeerManagerConnectedPeersResponse {}
53
54#[derive(Clone, Debug, PartialEq)]
55pub struct PeerManagerOnPeerConnectedRequest {
56    pub peer_id: fidl_fuchsia_bluetooth::PeerId,
57}
58
59impl fidl::Persistable for PeerManagerOnPeerConnectedRequest {}
60
61mod internal {
62    use super::*;
63    unsafe impl fidl::encoding::TypeMarker for PeerError {
64        type Owned = Self;
65
66        #[inline(always)]
67        fn inline_align(_context: fidl::encoding::Context) -> usize {
68            std::mem::align_of::<u32>()
69        }
70
71        #[inline(always)]
72        fn inline_size(_context: fidl::encoding::Context) -> usize {
73            std::mem::size_of::<u32>()
74        }
75
76        #[inline(always)]
77        fn encode_is_copy() -> bool {
78            true
79        }
80
81        #[inline(always)]
82        fn decode_is_copy() -> bool {
83            false
84        }
85    }
86
87    impl fidl::encoding::ValueTypeMarker for PeerError {
88        type Borrowed<'a> = Self;
89        #[inline(always)]
90        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
91            *value
92        }
93    }
94
95    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PeerError {
96        #[inline]
97        unsafe fn encode(
98            self,
99            encoder: &mut fidl::encoding::Encoder<'_, D>,
100            offset: usize,
101            _depth: fidl::encoding::Depth,
102        ) -> fidl::Result<()> {
103            encoder.debug_check_bounds::<Self>(offset);
104            encoder.write_num(self.into_primitive(), offset);
105            Ok(())
106        }
107    }
108
109    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PeerError {
110        #[inline(always)]
111        fn new_empty() -> Self {
112            Self::UnknownFailure
113        }
114
115        #[inline]
116        unsafe fn decode(
117            &mut self,
118            decoder: &mut fidl::encoding::Decoder<'_, D>,
119            offset: usize,
120            _depth: fidl::encoding::Depth,
121        ) -> fidl::Result<()> {
122            decoder.debug_check_bounds::<Self>(offset);
123            let prim = decoder.read_num::<u32>(offset);
124
125            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
126            Ok(())
127        }
128    }
129
130    impl fidl::encoding::ValueTypeMarker for PeerManagerConnectedPeersResponse {
131        type Borrowed<'a> = &'a Self;
132        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
133            value
134        }
135    }
136
137    unsafe impl fidl::encoding::TypeMarker for PeerManagerConnectedPeersResponse {
138        type Owned = Self;
139
140        #[inline(always)]
141        fn inline_align(_context: fidl::encoding::Context) -> usize {
142            8
143        }
144
145        #[inline(always)]
146        fn inline_size(_context: fidl::encoding::Context) -> usize {
147            16
148        }
149    }
150
151    unsafe impl<D: fidl::encoding::ResourceDialect>
152        fidl::encoding::Encode<PeerManagerConnectedPeersResponse, D>
153        for &PeerManagerConnectedPeersResponse
154    {
155        #[inline]
156        unsafe fn encode(
157            self,
158            encoder: &mut fidl::encoding::Encoder<'_, D>,
159            offset: usize,
160            _depth: fidl::encoding::Depth,
161        ) -> fidl::Result<()> {
162            encoder.debug_check_bounds::<PeerManagerConnectedPeersResponse>(offset);
163            // Delegate to tuple encoding.
164            fidl::encoding::Encode::<PeerManagerConnectedPeersResponse, D>::encode(
165                (
166                    <fidl::encoding::Vector<fidl_fuchsia_bluetooth::PeerId, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_ids),
167                ),
168                encoder, offset, _depth
169            )
170        }
171    }
172    unsafe impl<
173            D: fidl::encoding::ResourceDialect,
174            T0: fidl::encoding::Encode<fidl::encoding::Vector<fidl_fuchsia_bluetooth::PeerId, 8>, D>,
175        > fidl::encoding::Encode<PeerManagerConnectedPeersResponse, D> for (T0,)
176    {
177        #[inline]
178        unsafe fn encode(
179            self,
180            encoder: &mut fidl::encoding::Encoder<'_, D>,
181            offset: usize,
182            depth: fidl::encoding::Depth,
183        ) -> fidl::Result<()> {
184            encoder.debug_check_bounds::<PeerManagerConnectedPeersResponse>(offset);
185            // Zero out padding regions. There's no need to apply masks
186            // because the unmasked parts will be overwritten by fields.
187            // Write the fields.
188            self.0.encode(encoder, offset + 0, depth)?;
189            Ok(())
190        }
191    }
192
193    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
194        for PeerManagerConnectedPeersResponse
195    {
196        #[inline(always)]
197        fn new_empty() -> Self {
198            Self {
199                peer_ids: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth::PeerId, 8>, D),
200            }
201        }
202
203        #[inline]
204        unsafe fn decode(
205            &mut self,
206            decoder: &mut fidl::encoding::Decoder<'_, D>,
207            offset: usize,
208            _depth: fidl::encoding::Depth,
209        ) -> fidl::Result<()> {
210            decoder.debug_check_bounds::<Self>(offset);
211            // Verify that padding bytes are zero.
212            fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth::PeerId, 8>, D, &mut self.peer_ids, decoder, offset + 0, _depth)?;
213            Ok(())
214        }
215    }
216
217    impl fidl::encoding::ValueTypeMarker for PeerManagerOnPeerConnectedRequest {
218        type Borrowed<'a> = &'a Self;
219        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
220            value
221        }
222    }
223
224    unsafe impl fidl::encoding::TypeMarker for PeerManagerOnPeerConnectedRequest {
225        type Owned = Self;
226
227        #[inline(always)]
228        fn inline_align(_context: fidl::encoding::Context) -> usize {
229            8
230        }
231
232        #[inline(always)]
233        fn inline_size(_context: fidl::encoding::Context) -> usize {
234            8
235        }
236    }
237
238    unsafe impl<D: fidl::encoding::ResourceDialect>
239        fidl::encoding::Encode<PeerManagerOnPeerConnectedRequest, D>
240        for &PeerManagerOnPeerConnectedRequest
241    {
242        #[inline]
243        unsafe fn encode(
244            self,
245            encoder: &mut fidl::encoding::Encoder<'_, D>,
246            offset: usize,
247            _depth: fidl::encoding::Depth,
248        ) -> fidl::Result<()> {
249            encoder.debug_check_bounds::<PeerManagerOnPeerConnectedRequest>(offset);
250            // Delegate to tuple encoding.
251            fidl::encoding::Encode::<PeerManagerOnPeerConnectedRequest, D>::encode(
252                (<fidl_fuchsia_bluetooth::PeerId as fidl::encoding::ValueTypeMarker>::borrow(
253                    &self.peer_id,
254                ),),
255                encoder,
256                offset,
257                _depth,
258            )
259        }
260    }
261    unsafe impl<
262            D: fidl::encoding::ResourceDialect,
263            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth::PeerId, D>,
264        > fidl::encoding::Encode<PeerManagerOnPeerConnectedRequest, D> for (T0,)
265    {
266        #[inline]
267        unsafe fn encode(
268            self,
269            encoder: &mut fidl::encoding::Encoder<'_, D>,
270            offset: usize,
271            depth: fidl::encoding::Depth,
272        ) -> fidl::Result<()> {
273            encoder.debug_check_bounds::<PeerManagerOnPeerConnectedRequest>(offset);
274            // Zero out padding regions. There's no need to apply masks
275            // because the unmasked parts will be overwritten by fields.
276            // Write the fields.
277            self.0.encode(encoder, offset + 0, depth)?;
278            Ok(())
279        }
280    }
281
282    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
283        for PeerManagerOnPeerConnectedRequest
284    {
285        #[inline(always)]
286        fn new_empty() -> Self {
287            Self { peer_id: fidl::new_empty!(fidl_fuchsia_bluetooth::PeerId, D) }
288        }
289
290        #[inline]
291        unsafe fn decode(
292            &mut self,
293            decoder: &mut fidl::encoding::Decoder<'_, D>,
294            offset: usize,
295            _depth: fidl::encoding::Depth,
296        ) -> fidl::Result<()> {
297            decoder.debug_check_bounds::<Self>(offset);
298            // Verify that padding bytes are zero.
299            fidl::decode!(
300                fidl_fuchsia_bluetooth::PeerId,
301                D,
302                &mut self.peer_id,
303                decoder,
304                offset + 0,
305                _depth
306            )?;
307            Ok(())
308        }
309    }
310}