fidl_fuchsia_bluetooth_pandora__common/
fidl_fuchsia_bluetooth_pandora__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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12pub enum ServiceError {
13    /// The requested component was already running.
14    AlreadyRunning,
15    /// The provided IP address could not be parsed.
16    InvalidIp,
17    /// A connection could not be established to the provided address.
18    ConnectionFailed,
19    /// The request failed internally.
20    Failed,
21    #[doc(hidden)]
22    __SourceBreaking { unknown_ordinal: u32 },
23}
24
25/// Pattern that matches an unknown `ServiceError` member.
26#[macro_export]
27macro_rules! ServiceErrorUnknown {
28    () => {
29        _
30    };
31}
32
33impl ServiceError {
34    #[inline]
35    pub fn from_primitive(prim: u32) -> Option<Self> {
36        match prim {
37            1 => Some(Self::AlreadyRunning),
38            2 => Some(Self::InvalidIp),
39            3 => Some(Self::ConnectionFailed),
40            4 => Some(Self::Failed),
41            _ => None,
42        }
43    }
44
45    #[inline]
46    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
47        match prim {
48            1 => Self::AlreadyRunning,
49            2 => Self::InvalidIp,
50            3 => Self::ConnectionFailed,
51            4 => Self::Failed,
52            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
53        }
54    }
55
56    #[inline]
57    pub fn unknown() -> Self {
58        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
59    }
60
61    #[inline]
62    pub const fn into_primitive(self) -> u32 {
63        match self {
64            Self::AlreadyRunning => 1,
65            Self::InvalidIp => 2,
66            Self::ConnectionFailed => 3,
67            Self::Failed => 4,
68            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
69        }
70    }
71
72    #[inline]
73    pub fn is_unknown(&self) -> bool {
74        match self {
75            Self::__SourceBreaking { unknown_ordinal: _ } => true,
76            _ => false,
77        }
78    }
79}
80
81#[derive(Clone, Debug, Default, PartialEq)]
82pub struct GrpcServerControllerStartRequest {
83    pub port: Option<u16>,
84    #[doc(hidden)]
85    pub __source_breaking: fidl::marker::SourceBreaking,
86}
87
88impl fidl::Persistable for GrpcServerControllerStartRequest {}
89
90#[derive(Clone, Debug, Default, PartialEq)]
91pub struct RootcanalClientControllerStartRequest {
92    pub ip: Option<String>,
93    pub port: Option<u16>,
94    #[doc(hidden)]
95    pub __source_breaking: fidl::marker::SourceBreaking,
96}
97
98impl fidl::Persistable for RootcanalClientControllerStartRequest {}
99
100pub mod grpc_server_controller_ordinals {
101    pub const START: u64 = 0x39b64f9031375c29;
102    pub const STOP: u64 = 0x4e8601feb5d930b9;
103}
104
105pub mod rootcanal_client_controller_ordinals {
106    pub const START: u64 = 0xde429b8e402832c;
107    pub const STOP: u64 = 0x30419bba3f039d1d;
108}
109
110mod internal {
111    use super::*;
112    unsafe impl fidl::encoding::TypeMarker for ServiceError {
113        type Owned = Self;
114
115        #[inline(always)]
116        fn inline_align(_context: fidl::encoding::Context) -> usize {
117            std::mem::align_of::<u32>()
118        }
119
120        #[inline(always)]
121        fn inline_size(_context: fidl::encoding::Context) -> usize {
122            std::mem::size_of::<u32>()
123        }
124
125        #[inline(always)]
126        fn encode_is_copy() -> bool {
127            false
128        }
129
130        #[inline(always)]
131        fn decode_is_copy() -> bool {
132            false
133        }
134    }
135
136    impl fidl::encoding::ValueTypeMarker for ServiceError {
137        type Borrowed<'a> = Self;
138        #[inline(always)]
139        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
140            *value
141        }
142    }
143
144    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ServiceError {
145        #[inline]
146        unsafe fn encode(
147            self,
148            encoder: &mut fidl::encoding::Encoder<'_, D>,
149            offset: usize,
150            _depth: fidl::encoding::Depth,
151        ) -> fidl::Result<()> {
152            encoder.debug_check_bounds::<Self>(offset);
153            encoder.write_num(self.into_primitive(), offset);
154            Ok(())
155        }
156    }
157
158    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceError {
159        #[inline(always)]
160        fn new_empty() -> Self {
161            Self::unknown()
162        }
163
164        #[inline]
165        unsafe fn decode(
166            &mut self,
167            decoder: &mut fidl::encoding::Decoder<'_, D>,
168            offset: usize,
169            _depth: fidl::encoding::Depth,
170        ) -> fidl::Result<()> {
171            decoder.debug_check_bounds::<Self>(offset);
172            let prim = decoder.read_num::<u32>(offset);
173
174            *self = Self::from_primitive_allow_unknown(prim);
175            Ok(())
176        }
177    }
178
179    impl GrpcServerControllerStartRequest {
180        #[inline(always)]
181        fn max_ordinal_present(&self) -> u64 {
182            if let Some(_) = self.port {
183                return 1;
184            }
185            0
186        }
187    }
188
189    impl fidl::encoding::ValueTypeMarker for GrpcServerControllerStartRequest {
190        type Borrowed<'a> = &'a Self;
191        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
192            value
193        }
194    }
195
196    unsafe impl fidl::encoding::TypeMarker for GrpcServerControllerStartRequest {
197        type Owned = Self;
198
199        #[inline(always)]
200        fn inline_align(_context: fidl::encoding::Context) -> usize {
201            8
202        }
203
204        #[inline(always)]
205        fn inline_size(_context: fidl::encoding::Context) -> usize {
206            16
207        }
208    }
209
210    unsafe impl<D: fidl::encoding::ResourceDialect>
211        fidl::encoding::Encode<GrpcServerControllerStartRequest, D>
212        for &GrpcServerControllerStartRequest
213    {
214        unsafe fn encode(
215            self,
216            encoder: &mut fidl::encoding::Encoder<'_, D>,
217            offset: usize,
218            mut depth: fidl::encoding::Depth,
219        ) -> fidl::Result<()> {
220            encoder.debug_check_bounds::<GrpcServerControllerStartRequest>(offset);
221            // Vector header
222            let max_ordinal: u64 = self.max_ordinal_present();
223            encoder.write_num(max_ordinal, offset);
224            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
225            // Calling encoder.out_of_line_offset(0) is not allowed.
226            if max_ordinal == 0 {
227                return Ok(());
228            }
229            depth.increment()?;
230            let envelope_size = 8;
231            let bytes_len = max_ordinal as usize * envelope_size;
232            #[allow(unused_variables)]
233            let offset = encoder.out_of_line_offset(bytes_len);
234            let mut _prev_end_offset: usize = 0;
235            if 1 > max_ordinal {
236                return Ok(());
237            }
238
239            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
240            // are envelope_size bytes.
241            let cur_offset: usize = (1 - 1) * envelope_size;
242
243            // Zero reserved fields.
244            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
245
246            // Safety:
247            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
248            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
249            //   envelope_size bytes, there is always sufficient room.
250            fidl::encoding::encode_in_envelope_optional::<u16, D>(
251                self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
252                encoder,
253                offset + cur_offset,
254                depth,
255            )?;
256
257            _prev_end_offset = cur_offset + envelope_size;
258
259            Ok(())
260        }
261    }
262
263    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
264        for GrpcServerControllerStartRequest
265    {
266        #[inline(always)]
267        fn new_empty() -> Self {
268            Self::default()
269        }
270
271        unsafe fn decode(
272            &mut self,
273            decoder: &mut fidl::encoding::Decoder<'_, D>,
274            offset: usize,
275            mut depth: fidl::encoding::Depth,
276        ) -> fidl::Result<()> {
277            decoder.debug_check_bounds::<Self>(offset);
278            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
279                None => return Err(fidl::Error::NotNullable),
280                Some(len) => len,
281            };
282            // Calling decoder.out_of_line_offset(0) is not allowed.
283            if len == 0 {
284                return Ok(());
285            };
286            depth.increment()?;
287            let envelope_size = 8;
288            let bytes_len = len * envelope_size;
289            let offset = decoder.out_of_line_offset(bytes_len)?;
290            // Decode the envelope for each type.
291            let mut _next_ordinal_to_read = 0;
292            let mut next_offset = offset;
293            let end_offset = offset + bytes_len;
294            _next_ordinal_to_read += 1;
295            if next_offset >= end_offset {
296                return Ok(());
297            }
298
299            // Decode unknown envelopes for gaps in ordinals.
300            while _next_ordinal_to_read < 1 {
301                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
302                _next_ordinal_to_read += 1;
303                next_offset += envelope_size;
304            }
305
306            let next_out_of_line = decoder.next_out_of_line();
307            let handles_before = decoder.remaining_handles();
308            if let Some((inlined, num_bytes, num_handles)) =
309                fidl::encoding::decode_envelope_header(decoder, next_offset)?
310            {
311                let member_inline_size =
312                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
313                if inlined != (member_inline_size <= 4) {
314                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
315                }
316                let inner_offset;
317                let mut inner_depth = depth.clone();
318                if inlined {
319                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
320                    inner_offset = next_offset;
321                } else {
322                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
323                    inner_depth.increment()?;
324                }
325                let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
326                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
327                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
328                {
329                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
330                }
331                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
332                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
333                }
334            }
335
336            next_offset += envelope_size;
337
338            // Decode the remaining unknown envelopes.
339            while next_offset < end_offset {
340                _next_ordinal_to_read += 1;
341                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
342                next_offset += envelope_size;
343            }
344
345            Ok(())
346        }
347    }
348
349    impl RootcanalClientControllerStartRequest {
350        #[inline(always)]
351        fn max_ordinal_present(&self) -> u64 {
352            if let Some(_) = self.port {
353                return 2;
354            }
355            if let Some(_) = self.ip {
356                return 1;
357            }
358            0
359        }
360    }
361
362    impl fidl::encoding::ValueTypeMarker for RootcanalClientControllerStartRequest {
363        type Borrowed<'a> = &'a Self;
364        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
365            value
366        }
367    }
368
369    unsafe impl fidl::encoding::TypeMarker for RootcanalClientControllerStartRequest {
370        type Owned = Self;
371
372        #[inline(always)]
373        fn inline_align(_context: fidl::encoding::Context) -> usize {
374            8
375        }
376
377        #[inline(always)]
378        fn inline_size(_context: fidl::encoding::Context) -> usize {
379            16
380        }
381    }
382
383    unsafe impl<D: fidl::encoding::ResourceDialect>
384        fidl::encoding::Encode<RootcanalClientControllerStartRequest, D>
385        for &RootcanalClientControllerStartRequest
386    {
387        unsafe fn encode(
388            self,
389            encoder: &mut fidl::encoding::Encoder<'_, D>,
390            offset: usize,
391            mut depth: fidl::encoding::Depth,
392        ) -> fidl::Result<()> {
393            encoder.debug_check_bounds::<RootcanalClientControllerStartRequest>(offset);
394            // Vector header
395            let max_ordinal: u64 = self.max_ordinal_present();
396            encoder.write_num(max_ordinal, offset);
397            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
398            // Calling encoder.out_of_line_offset(0) is not allowed.
399            if max_ordinal == 0 {
400                return Ok(());
401            }
402            depth.increment()?;
403            let envelope_size = 8;
404            let bytes_len = max_ordinal as usize * envelope_size;
405            #[allow(unused_variables)]
406            let offset = encoder.out_of_line_offset(bytes_len);
407            let mut _prev_end_offset: usize = 0;
408            if 1 > max_ordinal {
409                return Ok(());
410            }
411
412            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
413            // are envelope_size bytes.
414            let cur_offset: usize = (1 - 1) * envelope_size;
415
416            // Zero reserved fields.
417            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
418
419            // Safety:
420            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
421            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
422            //   envelope_size bytes, there is always sufficient room.
423            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
424                self.ip.as_ref().map(
425                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
426                ),
427                encoder,
428                offset + cur_offset,
429                depth,
430            )?;
431
432            _prev_end_offset = cur_offset + envelope_size;
433            if 2 > max_ordinal {
434                return Ok(());
435            }
436
437            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
438            // are envelope_size bytes.
439            let cur_offset: usize = (2 - 1) * envelope_size;
440
441            // Zero reserved fields.
442            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
443
444            // Safety:
445            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
446            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
447            //   envelope_size bytes, there is always sufficient room.
448            fidl::encoding::encode_in_envelope_optional::<u16, D>(
449                self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
450                encoder,
451                offset + cur_offset,
452                depth,
453            )?;
454
455            _prev_end_offset = cur_offset + envelope_size;
456
457            Ok(())
458        }
459    }
460
461    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
462        for RootcanalClientControllerStartRequest
463    {
464        #[inline(always)]
465        fn new_empty() -> Self {
466            Self::default()
467        }
468
469        unsafe fn decode(
470            &mut self,
471            decoder: &mut fidl::encoding::Decoder<'_, D>,
472            offset: usize,
473            mut depth: fidl::encoding::Depth,
474        ) -> fidl::Result<()> {
475            decoder.debug_check_bounds::<Self>(offset);
476            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
477                None => return Err(fidl::Error::NotNullable),
478                Some(len) => len,
479            };
480            // Calling decoder.out_of_line_offset(0) is not allowed.
481            if len == 0 {
482                return Ok(());
483            };
484            depth.increment()?;
485            let envelope_size = 8;
486            let bytes_len = len * envelope_size;
487            let offset = decoder.out_of_line_offset(bytes_len)?;
488            // Decode the envelope for each type.
489            let mut _next_ordinal_to_read = 0;
490            let mut next_offset = offset;
491            let end_offset = offset + bytes_len;
492            _next_ordinal_to_read += 1;
493            if next_offset >= end_offset {
494                return Ok(());
495            }
496
497            // Decode unknown envelopes for gaps in ordinals.
498            while _next_ordinal_to_read < 1 {
499                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
500                _next_ordinal_to_read += 1;
501                next_offset += envelope_size;
502            }
503
504            let next_out_of_line = decoder.next_out_of_line();
505            let handles_before = decoder.remaining_handles();
506            if let Some((inlined, num_bytes, num_handles)) =
507                fidl::encoding::decode_envelope_header(decoder, next_offset)?
508            {
509                let member_inline_size =
510                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
511                        decoder.context,
512                    );
513                if inlined != (member_inline_size <= 4) {
514                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
515                }
516                let inner_offset;
517                let mut inner_depth = depth.clone();
518                if inlined {
519                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
520                    inner_offset = next_offset;
521                } else {
522                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
523                    inner_depth.increment()?;
524                }
525                let val_ref = self
526                    .ip
527                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
528                fidl::decode!(
529                    fidl::encoding::BoundedString<32>,
530                    D,
531                    val_ref,
532                    decoder,
533                    inner_offset,
534                    inner_depth
535                )?;
536                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
537                {
538                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
539                }
540                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
541                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
542                }
543            }
544
545            next_offset += envelope_size;
546            _next_ordinal_to_read += 1;
547            if next_offset >= end_offset {
548                return Ok(());
549            }
550
551            // Decode unknown envelopes for gaps in ordinals.
552            while _next_ordinal_to_read < 2 {
553                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
554                _next_ordinal_to_read += 1;
555                next_offset += envelope_size;
556            }
557
558            let next_out_of_line = decoder.next_out_of_line();
559            let handles_before = decoder.remaining_handles();
560            if let Some((inlined, num_bytes, num_handles)) =
561                fidl::encoding::decode_envelope_header(decoder, next_offset)?
562            {
563                let member_inline_size =
564                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
565                if inlined != (member_inline_size <= 4) {
566                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
567                }
568                let inner_offset;
569                let mut inner_depth = depth.clone();
570                if inlined {
571                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
572                    inner_offset = next_offset;
573                } else {
574                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
575                    inner_depth.increment()?;
576                }
577                let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
578                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
579                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
580                {
581                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
582                }
583                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
584                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
585                }
586            }
587
588            next_offset += envelope_size;
589
590            // Decode the remaining unknown envelopes.
591            while next_offset < end_offset {
592                _next_ordinal_to_read += 1;
593                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
594                next_offset += envelope_size;
595            }
596
597            Ok(())
598        }
599    }
600}