1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5#[derive(Debug)]
6#[repr(C)]
7pub struct CloneableCloneRequest {
8 pub request: ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel, crate::Cloneable>,
9}
10
11impl ::fidl_next::Encodable for CloneableCloneRequest {
12 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
13 ::fidl_next::CopyOptimization::enable_if(
14 true
15
16 && <
17 ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Cloneable,
18 > as ::fidl_next::Encodable
19 >::COPY_OPTIMIZATION.is_enabled()
20
21 )
22 };
23
24 type Encoded = WireCloneableCloneRequest;
25}
26
27unsafe impl<___E> ::fidl_next::Encode<___E> for CloneableCloneRequest
28where
29 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
30
31 ___E: ::fidl_next::fuchsia::HandleEncoder,
32{
33 #[inline]
34 fn encode(
35 self,
36 encoder: &mut ___E,
37 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
38 ) -> Result<(), ::fidl_next::EncodeError> {
39 ::fidl_next::munge! {
40 let Self::Encoded {
41 request,
42
43 } = out;
44 }
45
46 ::fidl_next::Encode::encode(self.request, encoder, request)?;
47
48 Ok(())
49 }
50}
51
52impl ::fidl_next::EncodableOption for Box<CloneableCloneRequest> {
53 type EncodedOption = ::fidl_next::WireBox<WireCloneableCloneRequest>;
54}
55
56unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<CloneableCloneRequest>
57where
58 ___E: ::fidl_next::Encoder + ?Sized,
59 CloneableCloneRequest: ::fidl_next::Encode<___E>,
60{
61 #[inline]
62 fn encode_option(
63 this: Option<Self>,
64 encoder: &mut ___E,
65 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
66 ) -> Result<(), ::fidl_next::EncodeError> {
67 if let Some(inner) = this {
68 ::fidl_next::EncoderExt::encode_next(encoder, *inner)?;
69 ::fidl_next::WireBox::encode_present(out);
70 } else {
71 ::fidl_next::WireBox::encode_absent(out);
72 }
73
74 Ok(())
75 }
76}
77
78impl ::fidl_next::TakeFrom<WireCloneableCloneRequest> for CloneableCloneRequest {
79 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self> = unsafe {
80 ::fidl_next::CopyOptimization::enable_if(
81 true
82
83 && <
84 ::fidl_next::ServerEnd<::fidl_next::fuchsia::zx::Channel,crate::Cloneable,
85 > as ::fidl_next::Encodable
86 >::COPY_OPTIMIZATION.is_enabled()
87
88 )
89 };
90
91 #[inline]
92 fn take_from(from: &WireCloneableCloneRequest) -> Self {
93 Self { request: ::fidl_next::TakeFrom::take_from(&from.request) }
94 }
95}
96
97#[derive(Debug)]
99#[repr(C)]
100pub struct WireCloneableCloneRequest {
101 pub request: ::fidl_next::ServerEnd<::fidl_next::fuchsia::WireChannel, crate::Cloneable>,
102}
103
104unsafe impl ::fidl_next::ZeroPadding for WireCloneableCloneRequest {
105 #[inline]
106 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
107}
108
109unsafe impl<___D> ::fidl_next::Decode<___D> for WireCloneableCloneRequest
110where
111 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
112
113 ___D: ::fidl_next::fuchsia::HandleDecoder,
114{
115 fn decode(
116 slot: ::fidl_next::Slot<'_, Self>,
117 decoder: &mut ___D,
118 ) -> Result<(), ::fidl_next::DecodeError> {
119 ::fidl_next::munge! {
120 let Self {
121 mut request,
122
123 } = slot;
124 }
125
126 ::fidl_next::Decode::decode(request.as_mut(), decoder)?;
127
128 Ok(())
129 }
130}
131
132#[doc = " Provides a means of duplicating a connection.\n\n See the composing protocol\'s documentation for a description of\n connection-scoped state, if any.\n"]
134#[derive(Debug)]
135pub struct Cloneable;
136
137pub mod cloneable {
138 pub mod prelude {
139 pub use crate::{
140 cloneable, Cloneable, CloneableClientHandler, CloneableClientSender,
141 CloneableServerHandler, CloneableServerSender,
142 };
143
144 pub use crate::CloneableCloneRequest;
145 }
146
147 pub struct Clone;
148
149 impl ::fidl_next::Method for Clone {
150 const ORDINAL: u64 = 2366825959783828089;
151
152 type Protocol = crate::Cloneable;
153
154 type Request = crate::WireCloneableCloneRequest;
155
156 type Response = ::fidl_next::Never;
157 }
158}
159
160pub trait CloneableClientSender {
162 type Transport: ::fidl_next::Transport;
163
164 fn clone<___R>(
165 &self,
166 request: ___R,
167 ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
168 where
169 ___R: ::fidl_next::Encode<
170 <Self::Transport as ::fidl_next::Transport>::SendBuffer,
171 Encoded = crate::WireCloneableCloneRequest,
172 >;
173}
174
175impl<___T> CloneableClientSender for ::fidl_next::ClientSender<___T, Cloneable>
176where
177 ___T: ::fidl_next::Transport,
178{
179 type Transport = ___T;
180
181 fn clone<___R>(
182 &self,
183 request: ___R,
184 ) -> Result<::fidl_next::SendFuture<'_, Self::Transport>, ::fidl_next::EncodeError>
185 where
186 ___R: ::fidl_next::Encode<
187 <Self::Transport as ::fidl_next::Transport>::SendBuffer,
188 Encoded = crate::WireCloneableCloneRequest,
189 >,
190 {
191 self.as_untyped().send_one_way(2366825959783828089, request)
192 }
193}
194
195pub trait CloneableClientHandler<___T: ::fidl_next::Transport> {}
199
200impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Cloneable
201where
202 ___T: ::fidl_next::Transport,
203 ___H: CloneableClientHandler<___T>,
204{
205 fn on_event(
206 handler: &mut ___H,
207 sender: &::fidl_next::ClientSender<___T, Self>,
208 ordinal: u64,
209 buffer: ___T::RecvBuffer,
210 ) {
211 match ordinal {
212 ordinal => {
213 sender.close();
214 }
215 }
216 }
217}
218
219pub trait CloneableServerSender {
221 type Transport: ::fidl_next::Transport;
222}
223
224impl<___T> CloneableServerSender for ::fidl_next::ServerSender<___T, Cloneable>
225where
226 ___T: ::fidl_next::Transport,
227{
228 type Transport = ___T;
229}
230
231pub trait CloneableServerHandler<___T: ::fidl_next::Transport> {
235 fn clone(
236 &mut self,
237 sender: &::fidl_next::ServerSender<___T, Cloneable>,
238
239 request: ::fidl_next::Request<___T, cloneable::Clone>,
240 );
241}
242
243impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Cloneable
244where
245 ___T: ::fidl_next::Transport,
246 ___H: CloneableServerHandler<___T>,
247
248 crate::WireCloneableCloneRequest:
249 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
250{
251 fn on_one_way(
252 handler: &mut ___H,
253 sender: &::fidl_next::ServerSender<___T, Self>,
254 ordinal: u64,
255 buffer: ___T::RecvBuffer,
256 ) {
257 match ordinal {
258 2366825959783828089 => match ::fidl_next::DecoderExt::decode(buffer) {
259 Ok(decoded) => handler.clone(sender, decoded),
260 Err(e) => {
261 sender.close();
262 }
263 },
264
265 ordinal => {
266 sender.close();
267 }
268 }
269 }
270
271 fn on_two_way(
272 handler: &mut ___H,
273 sender: &::fidl_next::ServerSender<___T, Self>,
274 ordinal: u64,
275 buffer: ___T::RecvBuffer,
276 responder: ::fidl_next::protocol::Responder,
277 ) {
278 match ordinal {
279 ordinal => {
280 sender.close();
281 }
282 }
283 }
284}
285
286pub type CloseableCloseResponse = ();
287
288pub type WireCloseableCloseResponse = ();
290
291#[doc = " Provides a means of synchronously closing a connection.\n"]
293#[derive(Debug)]
294pub struct Closeable;
295
296pub mod closeable {
297 pub mod prelude {
298 pub use crate::{
299 closeable, Closeable, CloseableClientHandler, CloseableClientSender,
300 CloseableServerHandler, CloseableServerSender,
301 };
302
303 pub use crate::CloseableCloseResponse;
304 }
305
306 pub struct Close;
307
308 impl ::fidl_next::Method for Close {
309 const ORDINAL: u64 = 6540867515453498750;
310
311 type Protocol = crate::Closeable;
312
313 type Request = ();
314
315 type Response =
316 ::fidl_next::WireResult<crate::WireCloseableCloseResponse, ::fidl_next::WireI32>;
317 }
318}
319
320pub trait CloseableClientSender {
322 type Transport: ::fidl_next::Transport;
323
324 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
325 fn close(
326 &self,
327 ) -> Result<
328 ::fidl_next::ResponseFuture<'_, Self::Transport, closeable::Close>,
329 ::fidl_next::EncodeError,
330 >;
331}
332
333impl<___T> CloseableClientSender for ::fidl_next::ClientSender<___T, Closeable>
334where
335 ___T: ::fidl_next::Transport,
336{
337 type Transport = ___T;
338
339 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
340 fn close(
341 &self,
342 ) -> Result<
343 ::fidl_next::ResponseFuture<'_, Self::Transport, closeable::Close>,
344 ::fidl_next::EncodeError,
345 > {
346 self.as_untyped()
347 .send_two_way(6540867515453498750, ())
348 .map(::fidl_next::ResponseFuture::from_untyped)
349 }
350}
351
352pub trait CloseableClientHandler<___T: ::fidl_next::Transport> {}
356
357impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Closeable
358where
359 ___T: ::fidl_next::Transport,
360 ___H: CloseableClientHandler<___T>,
361
362 <closeable::Close as ::fidl_next::Method>::Response:
363 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
364{
365 fn on_event(
366 handler: &mut ___H,
367 sender: &::fidl_next::ClientSender<___T, Self>,
368 ordinal: u64,
369 buffer: ___T::RecvBuffer,
370 ) {
371 match ordinal {
372 ordinal => {
373 sender.close();
374 }
375 }
376 }
377}
378
379pub trait CloseableServerSender {
381 type Transport: ::fidl_next::Transport;
382}
383
384impl<___T> CloseableServerSender for ::fidl_next::ServerSender<___T, Closeable>
385where
386 ___T: ::fidl_next::Transport,
387{
388 type Transport = ___T;
389}
390
391pub trait CloseableServerHandler<___T: ::fidl_next::Transport> {
395 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
396 fn close(
397 &mut self,
398 sender: &::fidl_next::ServerSender<___T, Closeable>,
399
400 responder: ::fidl_next::Responder<closeable::Close>,
401 );
402}
403
404impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Closeable
405where
406 ___T: ::fidl_next::Transport,
407 ___H: CloseableServerHandler<___T>,
408{
409 fn on_one_way(
410 handler: &mut ___H,
411 sender: &::fidl_next::ServerSender<___T, Self>,
412 ordinal: u64,
413 buffer: ___T::RecvBuffer,
414 ) {
415 match ordinal {
416 ordinal => {
417 sender.close();
418 }
419 }
420 }
421
422 fn on_two_way(
423 handler: &mut ___H,
424 sender: &::fidl_next::ServerSender<___T, Self>,
425 ordinal: u64,
426 buffer: ___T::RecvBuffer,
427 responder: ::fidl_next::protocol::Responder,
428 ) {
429 match ordinal {
430 6540867515453498750 => {
431 let responder = ::fidl_next::Responder::from_untyped(responder);
432
433 handler.close(sender, responder);
434 }
435
436 ordinal => {
437 sender.close();
438 }
439 }
440 }
441}
442
443#[derive(Clone, Debug)]
444pub struct QueryableQueryResponse {
445 pub protocol: Vec<u8>,
446}
447
448impl ::fidl_next::Encodable for QueryableQueryResponse {
449 type Encoded = WireQueryableQueryResponse;
450}
451
452unsafe impl<___E> ::fidl_next::Encode<___E> for QueryableQueryResponse
453where
454 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
455
456 ___E: ::fidl_next::Encoder,
457{
458 #[inline]
459 fn encode(
460 self,
461 encoder: &mut ___E,
462 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
463 ) -> Result<(), ::fidl_next::EncodeError> {
464 ::fidl_next::munge! {
465 let Self::Encoded {
466 protocol,
467
468 } = out;
469 }
470
471 ::fidl_next::Encode::encode(self.protocol, encoder, protocol)?;
472
473 Ok(())
474 }
475}
476
477unsafe impl<___E> ::fidl_next::EncodeRef<___E> for QueryableQueryResponse
478where
479 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
480
481 ___E: ::fidl_next::Encoder,
482{
483 #[inline]
484 fn encode_ref(
485 &self,
486 encoder: &mut ___E,
487 out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
488 ) -> Result<(), ::fidl_next::EncodeError> {
489 ::fidl_next::munge! {
490 let Self::Encoded {
491 protocol,
492
493 } = out;
494 }
495
496 ::fidl_next::EncodeRef::encode_ref(&self.protocol, encoder, protocol)?;
497
498 Ok(())
499 }
500}
501
502impl ::fidl_next::EncodableOption for Box<QueryableQueryResponse> {
503 type EncodedOption = ::fidl_next::WireBox<WireQueryableQueryResponse>;
504}
505
506unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Box<QueryableQueryResponse>
507where
508 ___E: ::fidl_next::Encoder + ?Sized,
509 QueryableQueryResponse: ::fidl_next::Encode<___E>,
510{
511 #[inline]
512 fn encode_option(
513 this: Option<Self>,
514 encoder: &mut ___E,
515 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
516 ) -> Result<(), ::fidl_next::EncodeError> {
517 if let Some(inner) = this {
518 ::fidl_next::EncoderExt::encode_next(encoder, *inner)?;
519 ::fidl_next::WireBox::encode_present(out);
520 } else {
521 ::fidl_next::WireBox::encode_absent(out);
522 }
523
524 Ok(())
525 }
526}
527
528unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Box<QueryableQueryResponse>
529where
530 ___E: ::fidl_next::Encoder + ?Sized,
531 QueryableQueryResponse: ::fidl_next::EncodeRef<___E>,
532{
533 #[inline]
534 fn encode_option_ref(
535 this: Option<&Self>,
536 encoder: &mut ___E,
537 out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
538 ) -> Result<(), ::fidl_next::EncodeError> {
539 if let Some(inner) = this {
540 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
541 ::fidl_next::WireBox::encode_present(out);
542 } else {
543 ::fidl_next::WireBox::encode_absent(out);
544 }
545
546 Ok(())
547 }
548}
549
550impl ::fidl_next::TakeFrom<WireQueryableQueryResponse> for QueryableQueryResponse {
551 #[inline]
552 fn take_from(from: &WireQueryableQueryResponse) -> Self {
553 Self { protocol: ::fidl_next::TakeFrom::take_from(&from.protocol) }
554 }
555}
556
557#[derive(Debug)]
559#[repr(C)]
560pub struct WireQueryableQueryResponse {
561 pub protocol: ::fidl_next::WireVector<u8>,
562}
563
564unsafe impl ::fidl_next::ZeroPadding for WireQueryableQueryResponse {
565 #[inline]
566 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
567}
568
569unsafe impl<___D> ::fidl_next::Decode<___D> for WireQueryableQueryResponse
570where
571 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
572
573 ___D: ::fidl_next::Decoder,
574{
575 fn decode(
576 slot: ::fidl_next::Slot<'_, Self>,
577 decoder: &mut ___D,
578 ) -> Result<(), ::fidl_next::DecodeError> {
579 ::fidl_next::munge! {
580 let Self {
581 mut protocol,
582
583 } = slot;
584 }
585
586 ::fidl_next::Decode::decode(protocol.as_mut(), decoder)?;
587
588 Ok(())
589 }
590}
591
592#[doc = " Provides a means of identifying a type-erased protocol.\n"]
594#[derive(Debug)]
595pub struct Queryable;
596
597pub mod queryable {
598 pub mod prelude {
599 pub use crate::{
600 queryable, Queryable, QueryableClientHandler, QueryableClientSender,
601 QueryableServerHandler, QueryableServerSender,
602 };
603
604 pub use crate::QueryableQueryResponse;
605 }
606
607 pub struct Query;
608
609 impl ::fidl_next::Method for Query {
610 const ORDINAL: u64 = 2763219980499352582;
611
612 type Protocol = crate::Queryable;
613
614 type Request = ();
615
616 type Response = crate::WireQueryableQueryResponse;
617 }
618}
619
620pub trait QueryableClientSender {
622 type Transport: ::fidl_next::Transport;
623
624 fn query(
625 &self,
626 ) -> Result<
627 ::fidl_next::ResponseFuture<'_, Self::Transport, queryable::Query>,
628 ::fidl_next::EncodeError,
629 >;
630}
631
632impl<___T> QueryableClientSender for ::fidl_next::ClientSender<___T, Queryable>
633where
634 ___T: ::fidl_next::Transport,
635{
636 type Transport = ___T;
637
638 fn query(
639 &self,
640 ) -> Result<
641 ::fidl_next::ResponseFuture<'_, Self::Transport, queryable::Query>,
642 ::fidl_next::EncodeError,
643 > {
644 self.as_untyped()
645 .send_two_way(2763219980499352582, ())
646 .map(::fidl_next::ResponseFuture::from_untyped)
647 }
648}
649
650pub trait QueryableClientHandler<___T: ::fidl_next::Transport> {}
654
655impl<___T, ___H> ::fidl_next::ClientProtocol<___T, ___H> for Queryable
656where
657 ___T: ::fidl_next::Transport,
658 ___H: QueryableClientHandler<___T>,
659
660 <queryable::Query as ::fidl_next::Method>::Response:
661 ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
662{
663 fn on_event(
664 handler: &mut ___H,
665 sender: &::fidl_next::ClientSender<___T, Self>,
666 ordinal: u64,
667 buffer: ___T::RecvBuffer,
668 ) {
669 match ordinal {
670 ordinal => {
671 sender.close();
672 }
673 }
674 }
675}
676
677pub trait QueryableServerSender {
679 type Transport: ::fidl_next::Transport;
680}
681
682impl<___T> QueryableServerSender for ::fidl_next::ServerSender<___T, Queryable>
683where
684 ___T: ::fidl_next::Transport,
685{
686 type Transport = ___T;
687}
688
689pub trait QueryableServerHandler<___T: ::fidl_next::Transport> {
693 fn query(
694 &mut self,
695 sender: &::fidl_next::ServerSender<___T, Queryable>,
696
697 responder: ::fidl_next::Responder<queryable::Query>,
698 );
699}
700
701impl<___T, ___H> ::fidl_next::ServerProtocol<___T, ___H> for Queryable
702where
703 ___T: ::fidl_next::Transport,
704 ___H: QueryableServerHandler<___T>,
705{
706 fn on_one_way(
707 handler: &mut ___H,
708 sender: &::fidl_next::ServerSender<___T, Self>,
709 ordinal: u64,
710 buffer: ___T::RecvBuffer,
711 ) {
712 match ordinal {
713 ordinal => {
714 sender.close();
715 }
716 }
717 }
718
719 fn on_two_way(
720 handler: &mut ___H,
721 sender: &::fidl_next::ServerSender<___T, Self>,
722 ordinal: u64,
723 buffer: ___T::RecvBuffer,
724 responder: ::fidl_next::protocol::Responder,
725 ) {
726 match ordinal {
727 2763219980499352582 => {
728 let responder = ::fidl_next::Responder::from_untyped(responder);
729
730 handler.query(sender, responder);
731 }
732
733 ordinal => {
734 sender.close();
735 }
736 }
737 }
738}
739
740pub mod compat {
742
743 impl ::fidl_next::TakeFrom<crate::WireCloneableCloneRequest>
744 for ::fidl_fuchsia_unknown::CloneableCloneRequest
745 {
746 #[inline]
747 fn take_from(from: &crate::WireCloneableCloneRequest) -> Self {
748 Self { request: ::fidl_next::TakeFrom::take_from(&from.request) }
749 }
750 }
751
752 #[cfg(target_os = "fuchsia")]
753 pub type CloneableProxy =
756 ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Cloneable>;
757
758 impl ::fidl_next::TakeFrom<crate::Cloneable> for ::fidl_fuchsia_unknown::CloneableMarker {
759 #[inline]
760 fn take_from(from: &crate::Cloneable) -> Self {
761 Self
762 }
763 }
764
765 #[cfg(target_os = "fuchsia")]
766 pub type CloseableProxy =
769 ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Closeable>;
770
771 impl ::fidl_next::TakeFrom<crate::Closeable> for ::fidl_fuchsia_unknown::CloseableMarker {
772 #[inline]
773 fn take_from(from: &crate::Closeable) -> Self {
774 Self
775 }
776 }
777
778 impl ::fidl_next::TakeFrom<crate::WireQueryableQueryResponse>
779 for ::fidl_fuchsia_unknown::QueryableQueryResponse
780 {
781 #[inline]
782 fn take_from(from: &crate::WireQueryableQueryResponse) -> Self {
783 Self { protocol: ::fidl_next::TakeFrom::take_from(&from.protocol) }
784 }
785 }
786
787 #[cfg(target_os = "fuchsia")]
788 pub type QueryableProxy =
791 ::fidl_next::ClientSender<::fidl_next::fuchsia::zx::Channel, crate::Queryable>;
792
793 impl ::fidl_next::TakeFrom<crate::Queryable> for ::fidl_fuchsia_unknown::QueryableMarker {
794 #[inline]
795 fn take_from(from: &crate::Queryable) -> Self {
796 Self
797 }
798 }
799}