fidl_fuchsia_bluetooth_pandora__common/
fidl_fuchsia_bluetooth_pandora__common.rs1#![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 AlreadyRunning,
15 InvalidIp,
17 ConnectionFailed,
19 Failed,
21 #[doc(hidden)]
22 __SourceBreaking { unknown_ordinal: u32 },
23}
24
25#[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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
242
243 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
245
246 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
415
416 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
418
419 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 let cur_offset: usize = (2 - 1) * envelope_size;
440
441 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
443
444 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 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 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 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 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 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}