fidl_fuchsia_cobalt/
fidl_fuchsia_cobalt.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::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_cobalt_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
15pub struct AggregateAndUploadMarker;
16
17impl fidl::endpoints::ProtocolMarker for AggregateAndUploadMarker {
18    type Proxy = AggregateAndUploadProxy;
19    type RequestStream = AggregateAndUploadRequestStream;
20    #[cfg(target_os = "fuchsia")]
21    type SynchronousProxy = AggregateAndUploadSynchronousProxy;
22
23    const DEBUG_NAME: &'static str = "fuchsia.cobalt.AggregateAndUpload";
24}
25impl fidl::endpoints::DiscoverableProtocolMarker for AggregateAndUploadMarker {}
26
27pub trait AggregateAndUploadProxyInterface: Send + Sync {
28    type AggregateAndUploadMetricEventsResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
29        + Send;
30    fn r#aggregate_and_upload_metric_events(
31        &self,
32    ) -> Self::AggregateAndUploadMetricEventsResponseFut;
33}
34#[derive(Debug)]
35#[cfg(target_os = "fuchsia")]
36pub struct AggregateAndUploadSynchronousProxy {
37    client: fidl::client::sync::Client,
38}
39
40#[cfg(target_os = "fuchsia")]
41impl fidl::endpoints::SynchronousProxy for AggregateAndUploadSynchronousProxy {
42    type Proxy = AggregateAndUploadProxy;
43    type Protocol = AggregateAndUploadMarker;
44
45    fn from_channel(inner: fidl::Channel) -> Self {
46        Self::new(inner)
47    }
48
49    fn into_channel(self) -> fidl::Channel {
50        self.client.into_channel()
51    }
52
53    fn as_channel(&self) -> &fidl::Channel {
54        self.client.as_channel()
55    }
56}
57
58#[cfg(target_os = "fuchsia")]
59impl AggregateAndUploadSynchronousProxy {
60    pub fn new(channel: fidl::Channel) -> Self {
61        let protocol_name =
62            <AggregateAndUploadMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
63        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
64    }
65
66    pub fn into_channel(self) -> fidl::Channel {
67        self.client.into_channel()
68    }
69
70    /// Waits until an event arrives and returns it. It is safe for other
71    /// threads to make concurrent requests while waiting for an event.
72    pub fn wait_for_event(
73        &self,
74        deadline: zx::MonotonicInstant,
75    ) -> Result<AggregateAndUploadEvent, fidl::Error> {
76        AggregateAndUploadEvent::decode(self.client.wait_for_event(deadline)?)
77    }
78
79    pub fn r#aggregate_and_upload_metric_events(
80        &self,
81        ___deadline: zx::MonotonicInstant,
82    ) -> Result<(), fidl::Error> {
83        let _response =
84            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
85                (),
86                0x48db82fb20a16550,
87                fidl::encoding::DynamicFlags::empty(),
88                ___deadline,
89            )?;
90        Ok(_response)
91    }
92}
93
94#[cfg(target_os = "fuchsia")]
95impl From<AggregateAndUploadSynchronousProxy> for zx::Handle {
96    fn from(value: AggregateAndUploadSynchronousProxy) -> Self {
97        value.into_channel().into()
98    }
99}
100
101#[cfg(target_os = "fuchsia")]
102impl From<fidl::Channel> for AggregateAndUploadSynchronousProxy {
103    fn from(value: fidl::Channel) -> Self {
104        Self::new(value)
105    }
106}
107
108#[derive(Debug, Clone)]
109pub struct AggregateAndUploadProxy {
110    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
111}
112
113impl fidl::endpoints::Proxy for AggregateAndUploadProxy {
114    type Protocol = AggregateAndUploadMarker;
115
116    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
117        Self::new(inner)
118    }
119
120    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
121        self.client.into_channel().map_err(|client| Self { client })
122    }
123
124    fn as_channel(&self) -> &::fidl::AsyncChannel {
125        self.client.as_channel()
126    }
127}
128
129impl AggregateAndUploadProxy {
130    /// Create a new Proxy for fuchsia.cobalt/AggregateAndUpload.
131    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
132        let protocol_name =
133            <AggregateAndUploadMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
134        Self { client: fidl::client::Client::new(channel, protocol_name) }
135    }
136
137    /// Get a Stream of events from the remote end of the protocol.
138    ///
139    /// # Panics
140    ///
141    /// Panics if the event stream was already taken.
142    pub fn take_event_stream(&self) -> AggregateAndUploadEventStream {
143        AggregateAndUploadEventStream { event_receiver: self.client.take_event_receiver() }
144    }
145
146    pub fn r#aggregate_and_upload_metric_events(
147        &self,
148    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
149        AggregateAndUploadProxyInterface::r#aggregate_and_upload_metric_events(self)
150    }
151}
152
153impl AggregateAndUploadProxyInterface for AggregateAndUploadProxy {
154    type AggregateAndUploadMetricEventsResponseFut =
155        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
156    fn r#aggregate_and_upload_metric_events(
157        &self,
158    ) -> Self::AggregateAndUploadMetricEventsResponseFut {
159        fn _decode(
160            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
161        ) -> Result<(), fidl::Error> {
162            let _response = fidl::client::decode_transaction_body::<
163                fidl::encoding::EmptyPayload,
164                fidl::encoding::DefaultFuchsiaResourceDialect,
165                0x48db82fb20a16550,
166            >(_buf?)?;
167            Ok(_response)
168        }
169        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
170            (),
171            0x48db82fb20a16550,
172            fidl::encoding::DynamicFlags::empty(),
173            _decode,
174        )
175    }
176}
177
178pub struct AggregateAndUploadEventStream {
179    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
180}
181
182impl std::marker::Unpin for AggregateAndUploadEventStream {}
183
184impl futures::stream::FusedStream for AggregateAndUploadEventStream {
185    fn is_terminated(&self) -> bool {
186        self.event_receiver.is_terminated()
187    }
188}
189
190impl futures::Stream for AggregateAndUploadEventStream {
191    type Item = Result<AggregateAndUploadEvent, fidl::Error>;
192
193    fn poll_next(
194        mut self: std::pin::Pin<&mut Self>,
195        cx: &mut std::task::Context<'_>,
196    ) -> std::task::Poll<Option<Self::Item>> {
197        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
198            &mut self.event_receiver,
199            cx
200        )?) {
201            Some(buf) => std::task::Poll::Ready(Some(AggregateAndUploadEvent::decode(buf))),
202            None => std::task::Poll::Ready(None),
203        }
204    }
205}
206
207#[derive(Debug)]
208pub enum AggregateAndUploadEvent {}
209
210impl AggregateAndUploadEvent {
211    /// Decodes a message buffer as a [`AggregateAndUploadEvent`].
212    fn decode(
213        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
214    ) -> Result<AggregateAndUploadEvent, fidl::Error> {
215        let (bytes, _handles) = buf.split_mut();
216        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
217        debug_assert_eq!(tx_header.tx_id, 0);
218        match tx_header.ordinal {
219            _ => Err(fidl::Error::UnknownOrdinal {
220                ordinal: tx_header.ordinal,
221                protocol_name:
222                    <AggregateAndUploadMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
223            }),
224        }
225    }
226}
227
228/// A Stream of incoming requests for fuchsia.cobalt/AggregateAndUpload.
229pub struct AggregateAndUploadRequestStream {
230    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
231    is_terminated: bool,
232}
233
234impl std::marker::Unpin for AggregateAndUploadRequestStream {}
235
236impl futures::stream::FusedStream for AggregateAndUploadRequestStream {
237    fn is_terminated(&self) -> bool {
238        self.is_terminated
239    }
240}
241
242impl fidl::endpoints::RequestStream for AggregateAndUploadRequestStream {
243    type Protocol = AggregateAndUploadMarker;
244    type ControlHandle = AggregateAndUploadControlHandle;
245
246    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
247        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
248    }
249
250    fn control_handle(&self) -> Self::ControlHandle {
251        AggregateAndUploadControlHandle { inner: self.inner.clone() }
252    }
253
254    fn into_inner(
255        self,
256    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
257    {
258        (self.inner, self.is_terminated)
259    }
260
261    fn from_inner(
262        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
263        is_terminated: bool,
264    ) -> Self {
265        Self { inner, is_terminated }
266    }
267}
268
269impl futures::Stream for AggregateAndUploadRequestStream {
270    type Item = Result<AggregateAndUploadRequest, fidl::Error>;
271
272    fn poll_next(
273        mut self: std::pin::Pin<&mut Self>,
274        cx: &mut std::task::Context<'_>,
275    ) -> std::task::Poll<Option<Self::Item>> {
276        let this = &mut *self;
277        if this.inner.check_shutdown(cx) {
278            this.is_terminated = true;
279            return std::task::Poll::Ready(None);
280        }
281        if this.is_terminated {
282            panic!("polled AggregateAndUploadRequestStream after completion");
283        }
284        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
285            |bytes, handles| {
286                match this.inner.channel().read_etc(cx, bytes, handles) {
287                    std::task::Poll::Ready(Ok(())) => {}
288                    std::task::Poll::Pending => return std::task::Poll::Pending,
289                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
290                        this.is_terminated = true;
291                        return std::task::Poll::Ready(None);
292                    }
293                    std::task::Poll::Ready(Err(e)) => {
294                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
295                            e.into(),
296                        ))))
297                    }
298                }
299
300                // A message has been received from the channel
301                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
302
303                std::task::Poll::Ready(Some(match header.ordinal {
304                0x48db82fb20a16550 => {
305                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
306                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
307                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
308                    let control_handle = AggregateAndUploadControlHandle {
309                        inner: this.inner.clone(),
310                    };
311                    Ok(AggregateAndUploadRequest::AggregateAndUploadMetricEvents {
312                        responder: AggregateAndUploadAggregateAndUploadMetricEventsResponder {
313                            control_handle: std::mem::ManuallyDrop::new(control_handle),
314                            tx_id: header.tx_id,
315                        },
316                    })
317                }
318                _ => Err(fidl::Error::UnknownOrdinal {
319                    ordinal: header.ordinal,
320                    protocol_name: <AggregateAndUploadMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
321                }),
322            }))
323            },
324        )
325    }
326}
327
328/// Locally aggregates all collected metrics and uploads generated
329/// observations immediately. This is only to be used for Recovery, and
330/// should only be called once per Recovery attempt.
331///
332/// If AggregateAndUpload completes, then the collected metrics were uploaded
333/// to Cobalt successfully. Otherwise, AggregateAndUpload may continue to run
334/// until the calling service cancels the process when long running operation
335/// exceeds the specified timeout. The reason this may occur, is that
336/// AggregateAndUpload has a retry policy, and will retry any failures until
337/// the operation succeeds or is cancelled due to exceeding a specified
338/// timeout.
339#[derive(Debug)]
340pub enum AggregateAndUploadRequest {
341    AggregateAndUploadMetricEvents {
342        responder: AggregateAndUploadAggregateAndUploadMetricEventsResponder,
343    },
344}
345
346impl AggregateAndUploadRequest {
347    #[allow(irrefutable_let_patterns)]
348    pub fn into_aggregate_and_upload_metric_events(
349        self,
350    ) -> Option<(AggregateAndUploadAggregateAndUploadMetricEventsResponder)> {
351        if let AggregateAndUploadRequest::AggregateAndUploadMetricEvents { responder } = self {
352            Some((responder))
353        } else {
354            None
355        }
356    }
357
358    /// Name of the method defined in FIDL
359    pub fn method_name(&self) -> &'static str {
360        match *self {
361            AggregateAndUploadRequest::AggregateAndUploadMetricEvents { .. } => {
362                "aggregate_and_upload_metric_events"
363            }
364        }
365    }
366}
367
368#[derive(Debug, Clone)]
369pub struct AggregateAndUploadControlHandle {
370    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
371}
372
373impl fidl::endpoints::ControlHandle for AggregateAndUploadControlHandle {
374    fn shutdown(&self) {
375        self.inner.shutdown()
376    }
377    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
378        self.inner.shutdown_with_epitaph(status)
379    }
380
381    fn is_closed(&self) -> bool {
382        self.inner.channel().is_closed()
383    }
384    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
385        self.inner.channel().on_closed()
386    }
387
388    #[cfg(target_os = "fuchsia")]
389    fn signal_peer(
390        &self,
391        clear_mask: zx::Signals,
392        set_mask: zx::Signals,
393    ) -> Result<(), zx_status::Status> {
394        use fidl::Peered;
395        self.inner.channel().signal_peer(clear_mask, set_mask)
396    }
397}
398
399impl AggregateAndUploadControlHandle {}
400
401#[must_use = "FIDL methods require a response to be sent"]
402#[derive(Debug)]
403pub struct AggregateAndUploadAggregateAndUploadMetricEventsResponder {
404    control_handle: std::mem::ManuallyDrop<AggregateAndUploadControlHandle>,
405    tx_id: u32,
406}
407
408/// Set the the channel to be shutdown (see [`AggregateAndUploadControlHandle::shutdown`])
409/// if the responder is dropped without sending a response, so that the client
410/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
411impl std::ops::Drop for AggregateAndUploadAggregateAndUploadMetricEventsResponder {
412    fn drop(&mut self) {
413        self.control_handle.shutdown();
414        // Safety: drops once, never accessed again
415        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
416    }
417}
418
419impl fidl::endpoints::Responder for AggregateAndUploadAggregateAndUploadMetricEventsResponder {
420    type ControlHandle = AggregateAndUploadControlHandle;
421
422    fn control_handle(&self) -> &AggregateAndUploadControlHandle {
423        &self.control_handle
424    }
425
426    fn drop_without_shutdown(mut self) {
427        // Safety: drops once, never accessed again due to mem::forget
428        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
429        // Prevent Drop from running (which would shut down the channel)
430        std::mem::forget(self);
431    }
432}
433
434impl AggregateAndUploadAggregateAndUploadMetricEventsResponder {
435    /// Sends a response to the FIDL transaction.
436    ///
437    /// Sets the channel to shutdown if an error occurs.
438    pub fn send(self) -> Result<(), fidl::Error> {
439        let _result = self.send_raw();
440        if _result.is_err() {
441            self.control_handle.shutdown();
442        }
443        self.drop_without_shutdown();
444        _result
445    }
446
447    /// Similar to "send" but does not shutdown the channel if an error occurs.
448    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
449        let _result = self.send_raw();
450        self.drop_without_shutdown();
451        _result
452    }
453
454    fn send_raw(&self) -> Result<(), fidl::Error> {
455        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
456            (),
457            self.tx_id,
458            0x48db82fb20a16550,
459            fidl::encoding::DynamicFlags::empty(),
460        )
461    }
462}
463
464#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
465pub struct ControllerMarker;
466
467impl fidl::endpoints::ProtocolMarker for ControllerMarker {
468    type Proxy = ControllerProxy;
469    type RequestStream = ControllerRequestStream;
470    #[cfg(target_os = "fuchsia")]
471    type SynchronousProxy = ControllerSynchronousProxy;
472
473    const DEBUG_NAME: &'static str = "fuchsia.cobalt.Controller";
474}
475impl fidl::endpoints::DiscoverableProtocolMarker for ControllerMarker {}
476
477pub trait ControllerProxyInterface: Send + Sync {
478    type RequestSendSoonResponseFut: std::future::Future<Output = Result<bool, fidl::Error>> + Send;
479    fn r#request_send_soon(&self) -> Self::RequestSendSoonResponseFut;
480    type GenerateAggregatedObservationsResponseFut: std::future::Future<Output = Result<Vec<u64>, fidl::Error>>
481        + Send;
482    fn r#generate_aggregated_observations(
483        &self,
484        day_index: u32,
485        report_specs: &[ReportSpec],
486    ) -> Self::GenerateAggregatedObservationsResponseFut;
487    type ListenForInitializedResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
488        + Send;
489    fn r#listen_for_initialized(&self) -> Self::ListenForInitializedResponseFut;
490}
491#[derive(Debug)]
492#[cfg(target_os = "fuchsia")]
493pub struct ControllerSynchronousProxy {
494    client: fidl::client::sync::Client,
495}
496
497#[cfg(target_os = "fuchsia")]
498impl fidl::endpoints::SynchronousProxy for ControllerSynchronousProxy {
499    type Proxy = ControllerProxy;
500    type Protocol = ControllerMarker;
501
502    fn from_channel(inner: fidl::Channel) -> Self {
503        Self::new(inner)
504    }
505
506    fn into_channel(self) -> fidl::Channel {
507        self.client.into_channel()
508    }
509
510    fn as_channel(&self) -> &fidl::Channel {
511        self.client.as_channel()
512    }
513}
514
515#[cfg(target_os = "fuchsia")]
516impl ControllerSynchronousProxy {
517    pub fn new(channel: fidl::Channel) -> Self {
518        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
519        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
520    }
521
522    pub fn into_channel(self) -> fidl::Channel {
523        self.client.into_channel()
524    }
525
526    /// Waits until an event arrives and returns it. It is safe for other
527    /// threads to make concurrent requests while waiting for an event.
528    pub fn wait_for_event(
529        &self,
530        deadline: zx::MonotonicInstant,
531    ) -> Result<ControllerEvent, fidl::Error> {
532        ControllerEvent::decode(self.client.wait_for_event(deadline)?)
533    }
534
535    /// Requests that the collection of Observations that are currently cached
536    /// locally be sent to the Cobalt server soon. Cobalt will send the
537    /// Observations in one or more batches and will retry several times upon
538    /// failure. The response occurs only after that procedure is completed. A
539    /// return value of true indicates that all Observations were successfully
540    /// sent. A return value of false indicates otherwise.
541    pub fn r#request_send_soon(
542        &self,
543        ___deadline: zx::MonotonicInstant,
544    ) -> Result<bool, fidl::Error> {
545        let _response = self
546            .client
547            .send_query::<fidl::encoding::EmptyPayload, ControllerRequestSendSoonResponse>(
548                (),
549                0x554e66bab8f72e3d,
550                fidl::encoding::DynamicFlags::empty(),
551                ___deadline,
552            )?;
553        Ok(_response.success)
554    }
555
556    /// Triggers Cobalt to generate Observations based on locally aggregated
557    /// event data and write them to the local ObservationStore. In a non-test
558    /// environment this would normally be done periodically by a background
559    /// thread. In a test environment this method should be invoked against an
560    /// instance of the Cobalt FIDL service that was passed the flag
561    /// --start_event_aggregator_worker=false.
562    ///
563    /// `day_index` The index of the day for which locally aggregated
564    ///             Observations should be generated.
565    ///
566    /// `report_specs` A vector of specifications identifying the reports to
567    ///                return the number of observations for.
568    ///
569    /// Returns a vector whose k-th element is the number of observations
570    /// generated for the k-th element of `report_specs`. If `report_specs`
571    /// is the empty vector, then an empty vector is returned.
572    pub fn r#generate_aggregated_observations(
573        &self,
574        mut day_index: u32,
575        mut report_specs: &[ReportSpec],
576        ___deadline: zx::MonotonicInstant,
577    ) -> Result<Vec<u64>, fidl::Error> {
578        let _response = self.client.send_query::<
579            ControllerGenerateAggregatedObservationsRequest,
580            ControllerGenerateAggregatedObservationsResponse,
581        >(
582            (day_index, report_specs,),
583            0x79e058c9497f1ab1,
584            fidl::encoding::DynamicFlags::empty(),
585            ___deadline,
586        )?;
587        Ok(_response.num_obs)
588    }
589
590    /// Requests that the caller be notified after the Cobalt FIDL service
591    /// is in the fully-initialized state.
592    ///
593    /// Cobalt starts serving requests before it is fully initialized. In this
594    /// pre-initialized state it will buffer incoming log events in memory
595    /// but not complete their processing. After Cobalt becomes fully
596    /// initialized the events in the bufer are fully processed.
597    ///
598    /// A partial list of things that must happen before Cobalt enters the
599    /// fully-initialized state are:
600    ///
601    /// - Cobalt must by notified by the timekeeper service that the system
602    ///   clock has become accurate--usually because the time has been
603    ///   fetched from a trusted network resource.
604    ///
605    /// The callback to this method will be invoked after Cobalt transistions
606    pub fn r#listen_for_initialized(
607        &self,
608        ___deadline: zx::MonotonicInstant,
609    ) -> Result<(), fidl::Error> {
610        let _response =
611            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
612                (),
613                0x3454fbf05fcf10ef,
614                fidl::encoding::DynamicFlags::empty(),
615                ___deadline,
616            )?;
617        Ok(_response)
618    }
619}
620
621#[cfg(target_os = "fuchsia")]
622impl From<ControllerSynchronousProxy> for zx::Handle {
623    fn from(value: ControllerSynchronousProxy) -> Self {
624        value.into_channel().into()
625    }
626}
627
628#[cfg(target_os = "fuchsia")]
629impl From<fidl::Channel> for ControllerSynchronousProxy {
630    fn from(value: fidl::Channel) -> Self {
631        Self::new(value)
632    }
633}
634
635#[derive(Debug, Clone)]
636pub struct ControllerProxy {
637    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
638}
639
640impl fidl::endpoints::Proxy for ControllerProxy {
641    type Protocol = ControllerMarker;
642
643    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
644        Self::new(inner)
645    }
646
647    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
648        self.client.into_channel().map_err(|client| Self { client })
649    }
650
651    fn as_channel(&self) -> &::fidl::AsyncChannel {
652        self.client.as_channel()
653    }
654}
655
656impl ControllerProxy {
657    /// Create a new Proxy for fuchsia.cobalt/Controller.
658    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
659        let protocol_name = <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
660        Self { client: fidl::client::Client::new(channel, protocol_name) }
661    }
662
663    /// Get a Stream of events from the remote end of the protocol.
664    ///
665    /// # Panics
666    ///
667    /// Panics if the event stream was already taken.
668    pub fn take_event_stream(&self) -> ControllerEventStream {
669        ControllerEventStream { event_receiver: self.client.take_event_receiver() }
670    }
671
672    /// Requests that the collection of Observations that are currently cached
673    /// locally be sent to the Cobalt server soon. Cobalt will send the
674    /// Observations in one or more batches and will retry several times upon
675    /// failure. The response occurs only after that procedure is completed. A
676    /// return value of true indicates that all Observations were successfully
677    /// sent. A return value of false indicates otherwise.
678    pub fn r#request_send_soon(
679        &self,
680    ) -> fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect> {
681        ControllerProxyInterface::r#request_send_soon(self)
682    }
683
684    /// Triggers Cobalt to generate Observations based on locally aggregated
685    /// event data and write them to the local ObservationStore. In a non-test
686    /// environment this would normally be done periodically by a background
687    /// thread. In a test environment this method should be invoked against an
688    /// instance of the Cobalt FIDL service that was passed the flag
689    /// --start_event_aggregator_worker=false.
690    ///
691    /// `day_index` The index of the day for which locally aggregated
692    ///             Observations should be generated.
693    ///
694    /// `report_specs` A vector of specifications identifying the reports to
695    ///                return the number of observations for.
696    ///
697    /// Returns a vector whose k-th element is the number of observations
698    /// generated for the k-th element of `report_specs`. If `report_specs`
699    /// is the empty vector, then an empty vector is returned.
700    pub fn r#generate_aggregated_observations(
701        &self,
702        mut day_index: u32,
703        mut report_specs: &[ReportSpec],
704    ) -> fidl::client::QueryResponseFut<Vec<u64>, fidl::encoding::DefaultFuchsiaResourceDialect>
705    {
706        ControllerProxyInterface::r#generate_aggregated_observations(self, day_index, report_specs)
707    }
708
709    /// Requests that the caller be notified after the Cobalt FIDL service
710    /// is in the fully-initialized state.
711    ///
712    /// Cobalt starts serving requests before it is fully initialized. In this
713    /// pre-initialized state it will buffer incoming log events in memory
714    /// but not complete their processing. After Cobalt becomes fully
715    /// initialized the events in the bufer are fully processed.
716    ///
717    /// A partial list of things that must happen before Cobalt enters the
718    /// fully-initialized state are:
719    ///
720    /// - Cobalt must by notified by the timekeeper service that the system
721    ///   clock has become accurate--usually because the time has been
722    ///   fetched from a trusted network resource.
723    ///
724    /// The callback to this method will be invoked after Cobalt transistions
725    pub fn r#listen_for_initialized(
726        &self,
727    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
728        ControllerProxyInterface::r#listen_for_initialized(self)
729    }
730}
731
732impl ControllerProxyInterface for ControllerProxy {
733    type RequestSendSoonResponseFut =
734        fidl::client::QueryResponseFut<bool, fidl::encoding::DefaultFuchsiaResourceDialect>;
735    fn r#request_send_soon(&self) -> Self::RequestSendSoonResponseFut {
736        fn _decode(
737            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
738        ) -> Result<bool, fidl::Error> {
739            let _response = fidl::client::decode_transaction_body::<
740                ControllerRequestSendSoonResponse,
741                fidl::encoding::DefaultFuchsiaResourceDialect,
742                0x554e66bab8f72e3d,
743            >(_buf?)?;
744            Ok(_response.success)
745        }
746        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, bool>(
747            (),
748            0x554e66bab8f72e3d,
749            fidl::encoding::DynamicFlags::empty(),
750            _decode,
751        )
752    }
753
754    type GenerateAggregatedObservationsResponseFut =
755        fidl::client::QueryResponseFut<Vec<u64>, fidl::encoding::DefaultFuchsiaResourceDialect>;
756    fn r#generate_aggregated_observations(
757        &self,
758        mut day_index: u32,
759        mut report_specs: &[ReportSpec],
760    ) -> Self::GenerateAggregatedObservationsResponseFut {
761        fn _decode(
762            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
763        ) -> Result<Vec<u64>, fidl::Error> {
764            let _response = fidl::client::decode_transaction_body::<
765                ControllerGenerateAggregatedObservationsResponse,
766                fidl::encoding::DefaultFuchsiaResourceDialect,
767                0x79e058c9497f1ab1,
768            >(_buf?)?;
769            Ok(_response.num_obs)
770        }
771        self.client
772            .send_query_and_decode::<ControllerGenerateAggregatedObservationsRequest, Vec<u64>>(
773                (day_index, report_specs),
774                0x79e058c9497f1ab1,
775                fidl::encoding::DynamicFlags::empty(),
776                _decode,
777            )
778    }
779
780    type ListenForInitializedResponseFut =
781        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
782    fn r#listen_for_initialized(&self) -> Self::ListenForInitializedResponseFut {
783        fn _decode(
784            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
785        ) -> Result<(), fidl::Error> {
786            let _response = fidl::client::decode_transaction_body::<
787                fidl::encoding::EmptyPayload,
788                fidl::encoding::DefaultFuchsiaResourceDialect,
789                0x3454fbf05fcf10ef,
790            >(_buf?)?;
791            Ok(_response)
792        }
793        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
794            (),
795            0x3454fbf05fcf10ef,
796            fidl::encoding::DynamicFlags::empty(),
797            _decode,
798        )
799    }
800}
801
802pub struct ControllerEventStream {
803    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
804}
805
806impl std::marker::Unpin for ControllerEventStream {}
807
808impl futures::stream::FusedStream for ControllerEventStream {
809    fn is_terminated(&self) -> bool {
810        self.event_receiver.is_terminated()
811    }
812}
813
814impl futures::Stream for ControllerEventStream {
815    type Item = Result<ControllerEvent, fidl::Error>;
816
817    fn poll_next(
818        mut self: std::pin::Pin<&mut Self>,
819        cx: &mut std::task::Context<'_>,
820    ) -> std::task::Poll<Option<Self::Item>> {
821        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
822            &mut self.event_receiver,
823            cx
824        )?) {
825            Some(buf) => std::task::Poll::Ready(Some(ControllerEvent::decode(buf))),
826            None => std::task::Poll::Ready(None),
827        }
828    }
829}
830
831#[derive(Debug)]
832pub enum ControllerEvent {}
833
834impl ControllerEvent {
835    /// Decodes a message buffer as a [`ControllerEvent`].
836    fn decode(
837        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
838    ) -> Result<ControllerEvent, fidl::Error> {
839        let (bytes, _handles) = buf.split_mut();
840        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
841        debug_assert_eq!(tx_header.tx_id, 0);
842        match tx_header.ordinal {
843            _ => Err(fidl::Error::UnknownOrdinal {
844                ordinal: tx_header.ordinal,
845                protocol_name: <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
846            }),
847        }
848    }
849}
850
851/// A Stream of incoming requests for fuchsia.cobalt/Controller.
852pub struct ControllerRequestStream {
853    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
854    is_terminated: bool,
855}
856
857impl std::marker::Unpin for ControllerRequestStream {}
858
859impl futures::stream::FusedStream for ControllerRequestStream {
860    fn is_terminated(&self) -> bool {
861        self.is_terminated
862    }
863}
864
865impl fidl::endpoints::RequestStream for ControllerRequestStream {
866    type Protocol = ControllerMarker;
867    type ControlHandle = ControllerControlHandle;
868
869    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
870        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
871    }
872
873    fn control_handle(&self) -> Self::ControlHandle {
874        ControllerControlHandle { inner: self.inner.clone() }
875    }
876
877    fn into_inner(
878        self,
879    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
880    {
881        (self.inner, self.is_terminated)
882    }
883
884    fn from_inner(
885        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
886        is_terminated: bool,
887    ) -> Self {
888        Self { inner, is_terminated }
889    }
890}
891
892impl futures::Stream for ControllerRequestStream {
893    type Item = Result<ControllerRequest, fidl::Error>;
894
895    fn poll_next(
896        mut self: std::pin::Pin<&mut Self>,
897        cx: &mut std::task::Context<'_>,
898    ) -> std::task::Poll<Option<Self::Item>> {
899        let this = &mut *self;
900        if this.inner.check_shutdown(cx) {
901            this.is_terminated = true;
902            return std::task::Poll::Ready(None);
903        }
904        if this.is_terminated {
905            panic!("polled ControllerRequestStream after completion");
906        }
907        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
908            |bytes, handles| {
909                match this.inner.channel().read_etc(cx, bytes, handles) {
910                    std::task::Poll::Ready(Ok(())) => {}
911                    std::task::Poll::Pending => return std::task::Poll::Pending,
912                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
913                        this.is_terminated = true;
914                        return std::task::Poll::Ready(None);
915                    }
916                    std::task::Poll::Ready(Err(e)) => {
917                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
918                            e.into(),
919                        ))))
920                    }
921                }
922
923                // A message has been received from the channel
924                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
925
926                std::task::Poll::Ready(Some(match header.ordinal {
927                    0x554e66bab8f72e3d => {
928                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
929                        let mut req = fidl::new_empty!(
930                            fidl::encoding::EmptyPayload,
931                            fidl::encoding::DefaultFuchsiaResourceDialect
932                        );
933                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
934                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
935                        Ok(ControllerRequest::RequestSendSoon {
936                            responder: ControllerRequestSendSoonResponder {
937                                control_handle: std::mem::ManuallyDrop::new(control_handle),
938                                tx_id: header.tx_id,
939                            },
940                        })
941                    }
942                    0x79e058c9497f1ab1 => {
943                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
944                        let mut req = fidl::new_empty!(
945                            ControllerGenerateAggregatedObservationsRequest,
946                            fidl::encoding::DefaultFuchsiaResourceDialect
947                        );
948                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ControllerGenerateAggregatedObservationsRequest>(&header, _body_bytes, handles, &mut req)?;
949                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
950                        Ok(ControllerRequest::GenerateAggregatedObservations {
951                            day_index: req.day_index,
952                            report_specs: req.report_specs,
953
954                            responder: ControllerGenerateAggregatedObservationsResponder {
955                                control_handle: std::mem::ManuallyDrop::new(control_handle),
956                                tx_id: header.tx_id,
957                            },
958                        })
959                    }
960                    0x3454fbf05fcf10ef => {
961                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
962                        let mut req = fidl::new_empty!(
963                            fidl::encoding::EmptyPayload,
964                            fidl::encoding::DefaultFuchsiaResourceDialect
965                        );
966                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
967                        let control_handle = ControllerControlHandle { inner: this.inner.clone() };
968                        Ok(ControllerRequest::ListenForInitialized {
969                            responder: ControllerListenForInitializedResponder {
970                                control_handle: std::mem::ManuallyDrop::new(control_handle),
971                                tx_id: header.tx_id,
972                            },
973                        })
974                    }
975                    _ => Err(fidl::Error::UnknownOrdinal {
976                        ordinal: header.ordinal,
977                        protocol_name:
978                            <ControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
979                    }),
980                }))
981            },
982        )
983    }
984}
985
986/// The Controller is primarily useful for testing the Cobalt service.
987/// Cobalt clients should use the Logger.
988#[derive(Debug)]
989pub enum ControllerRequest {
990    /// Requests that the collection of Observations that are currently cached
991    /// locally be sent to the Cobalt server soon. Cobalt will send the
992    /// Observations in one or more batches and will retry several times upon
993    /// failure. The response occurs only after that procedure is completed. A
994    /// return value of true indicates that all Observations were successfully
995    /// sent. A return value of false indicates otherwise.
996    RequestSendSoon { responder: ControllerRequestSendSoonResponder },
997    /// Triggers Cobalt to generate Observations based on locally aggregated
998    /// event data and write them to the local ObservationStore. In a non-test
999    /// environment this would normally be done periodically by a background
1000    /// thread. In a test environment this method should be invoked against an
1001    /// instance of the Cobalt FIDL service that was passed the flag
1002    /// --start_event_aggregator_worker=false.
1003    ///
1004    /// `day_index` The index of the day for which locally aggregated
1005    ///             Observations should be generated.
1006    ///
1007    /// `report_specs` A vector of specifications identifying the reports to
1008    ///                return the number of observations for.
1009    ///
1010    /// Returns a vector whose k-th element is the number of observations
1011    /// generated for the k-th element of `report_specs`. If `report_specs`
1012    /// is the empty vector, then an empty vector is returned.
1013    GenerateAggregatedObservations {
1014        day_index: u32,
1015        report_specs: Vec<ReportSpec>,
1016        responder: ControllerGenerateAggregatedObservationsResponder,
1017    },
1018    /// Requests that the caller be notified after the Cobalt FIDL service
1019    /// is in the fully-initialized state.
1020    ///
1021    /// Cobalt starts serving requests before it is fully initialized. In this
1022    /// pre-initialized state it will buffer incoming log events in memory
1023    /// but not complete their processing. After Cobalt becomes fully
1024    /// initialized the events in the bufer are fully processed.
1025    ///
1026    /// A partial list of things that must happen before Cobalt enters the
1027    /// fully-initialized state are:
1028    ///
1029    /// - Cobalt must by notified by the timekeeper service that the system
1030    ///   clock has become accurate--usually because the time has been
1031    ///   fetched from a trusted network resource.
1032    ///
1033    /// The callback to this method will be invoked after Cobalt transistions
1034    ListenForInitialized { responder: ControllerListenForInitializedResponder },
1035}
1036
1037impl ControllerRequest {
1038    #[allow(irrefutable_let_patterns)]
1039    pub fn into_request_send_soon(self) -> Option<(ControllerRequestSendSoonResponder)> {
1040        if let ControllerRequest::RequestSendSoon { responder } = self {
1041            Some((responder))
1042        } else {
1043            None
1044        }
1045    }
1046
1047    #[allow(irrefutable_let_patterns)]
1048    pub fn into_generate_aggregated_observations(
1049        self,
1050    ) -> Option<(u32, Vec<ReportSpec>, ControllerGenerateAggregatedObservationsResponder)> {
1051        if let ControllerRequest::GenerateAggregatedObservations {
1052            day_index,
1053            report_specs,
1054            responder,
1055        } = self
1056        {
1057            Some((day_index, report_specs, responder))
1058        } else {
1059            None
1060        }
1061    }
1062
1063    #[allow(irrefutable_let_patterns)]
1064    pub fn into_listen_for_initialized(self) -> Option<(ControllerListenForInitializedResponder)> {
1065        if let ControllerRequest::ListenForInitialized { responder } = self {
1066            Some((responder))
1067        } else {
1068            None
1069        }
1070    }
1071
1072    /// Name of the method defined in FIDL
1073    pub fn method_name(&self) -> &'static str {
1074        match *self {
1075            ControllerRequest::RequestSendSoon { .. } => "request_send_soon",
1076            ControllerRequest::GenerateAggregatedObservations { .. } => {
1077                "generate_aggregated_observations"
1078            }
1079            ControllerRequest::ListenForInitialized { .. } => "listen_for_initialized",
1080        }
1081    }
1082}
1083
1084#[derive(Debug, Clone)]
1085pub struct ControllerControlHandle {
1086    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1087}
1088
1089impl fidl::endpoints::ControlHandle for ControllerControlHandle {
1090    fn shutdown(&self) {
1091        self.inner.shutdown()
1092    }
1093    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1094        self.inner.shutdown_with_epitaph(status)
1095    }
1096
1097    fn is_closed(&self) -> bool {
1098        self.inner.channel().is_closed()
1099    }
1100    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1101        self.inner.channel().on_closed()
1102    }
1103
1104    #[cfg(target_os = "fuchsia")]
1105    fn signal_peer(
1106        &self,
1107        clear_mask: zx::Signals,
1108        set_mask: zx::Signals,
1109    ) -> Result<(), zx_status::Status> {
1110        use fidl::Peered;
1111        self.inner.channel().signal_peer(clear_mask, set_mask)
1112    }
1113}
1114
1115impl ControllerControlHandle {}
1116
1117#[must_use = "FIDL methods require a response to be sent"]
1118#[derive(Debug)]
1119pub struct ControllerRequestSendSoonResponder {
1120    control_handle: std::mem::ManuallyDrop<ControllerControlHandle>,
1121    tx_id: u32,
1122}
1123
1124/// Set the the channel to be shutdown (see [`ControllerControlHandle::shutdown`])
1125/// if the responder is dropped without sending a response, so that the client
1126/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1127impl std::ops::Drop for ControllerRequestSendSoonResponder {
1128    fn drop(&mut self) {
1129        self.control_handle.shutdown();
1130        // Safety: drops once, never accessed again
1131        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1132    }
1133}
1134
1135impl fidl::endpoints::Responder for ControllerRequestSendSoonResponder {
1136    type ControlHandle = ControllerControlHandle;
1137
1138    fn control_handle(&self) -> &ControllerControlHandle {
1139        &self.control_handle
1140    }
1141
1142    fn drop_without_shutdown(mut self) {
1143        // Safety: drops once, never accessed again due to mem::forget
1144        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1145        // Prevent Drop from running (which would shut down the channel)
1146        std::mem::forget(self);
1147    }
1148}
1149
1150impl ControllerRequestSendSoonResponder {
1151    /// Sends a response to the FIDL transaction.
1152    ///
1153    /// Sets the channel to shutdown if an error occurs.
1154    pub fn send(self, mut success: bool) -> Result<(), fidl::Error> {
1155        let _result = self.send_raw(success);
1156        if _result.is_err() {
1157            self.control_handle.shutdown();
1158        }
1159        self.drop_without_shutdown();
1160        _result
1161    }
1162
1163    /// Similar to "send" but does not shutdown the channel if an error occurs.
1164    pub fn send_no_shutdown_on_err(self, mut success: bool) -> Result<(), fidl::Error> {
1165        let _result = self.send_raw(success);
1166        self.drop_without_shutdown();
1167        _result
1168    }
1169
1170    fn send_raw(&self, mut success: bool) -> Result<(), fidl::Error> {
1171        self.control_handle.inner.send::<ControllerRequestSendSoonResponse>(
1172            (success,),
1173            self.tx_id,
1174            0x554e66bab8f72e3d,
1175            fidl::encoding::DynamicFlags::empty(),
1176        )
1177    }
1178}
1179
1180#[must_use = "FIDL methods require a response to be sent"]
1181#[derive(Debug)]
1182pub struct ControllerGenerateAggregatedObservationsResponder {
1183    control_handle: std::mem::ManuallyDrop<ControllerControlHandle>,
1184    tx_id: u32,
1185}
1186
1187/// Set the the channel to be shutdown (see [`ControllerControlHandle::shutdown`])
1188/// if the responder is dropped without sending a response, so that the client
1189/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1190impl std::ops::Drop for ControllerGenerateAggregatedObservationsResponder {
1191    fn drop(&mut self) {
1192        self.control_handle.shutdown();
1193        // Safety: drops once, never accessed again
1194        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1195    }
1196}
1197
1198impl fidl::endpoints::Responder for ControllerGenerateAggregatedObservationsResponder {
1199    type ControlHandle = ControllerControlHandle;
1200
1201    fn control_handle(&self) -> &ControllerControlHandle {
1202        &self.control_handle
1203    }
1204
1205    fn drop_without_shutdown(mut self) {
1206        // Safety: drops once, never accessed again due to mem::forget
1207        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1208        // Prevent Drop from running (which would shut down the channel)
1209        std::mem::forget(self);
1210    }
1211}
1212
1213impl ControllerGenerateAggregatedObservationsResponder {
1214    /// Sends a response to the FIDL transaction.
1215    ///
1216    /// Sets the channel to shutdown if an error occurs.
1217    pub fn send(self, mut num_obs: &[u64]) -> Result<(), fidl::Error> {
1218        let _result = self.send_raw(num_obs);
1219        if _result.is_err() {
1220            self.control_handle.shutdown();
1221        }
1222        self.drop_without_shutdown();
1223        _result
1224    }
1225
1226    /// Similar to "send" but does not shutdown the channel if an error occurs.
1227    pub fn send_no_shutdown_on_err(self, mut num_obs: &[u64]) -> Result<(), fidl::Error> {
1228        let _result = self.send_raw(num_obs);
1229        self.drop_without_shutdown();
1230        _result
1231    }
1232
1233    fn send_raw(&self, mut num_obs: &[u64]) -> Result<(), fidl::Error> {
1234        self.control_handle.inner.send::<ControllerGenerateAggregatedObservationsResponse>(
1235            (num_obs,),
1236            self.tx_id,
1237            0x79e058c9497f1ab1,
1238            fidl::encoding::DynamicFlags::empty(),
1239        )
1240    }
1241}
1242
1243#[must_use = "FIDL methods require a response to be sent"]
1244#[derive(Debug)]
1245pub struct ControllerListenForInitializedResponder {
1246    control_handle: std::mem::ManuallyDrop<ControllerControlHandle>,
1247    tx_id: u32,
1248}
1249
1250/// Set the the channel to be shutdown (see [`ControllerControlHandle::shutdown`])
1251/// if the responder is dropped without sending a response, so that the client
1252/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1253impl std::ops::Drop for ControllerListenForInitializedResponder {
1254    fn drop(&mut self) {
1255        self.control_handle.shutdown();
1256        // Safety: drops once, never accessed again
1257        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1258    }
1259}
1260
1261impl fidl::endpoints::Responder for ControllerListenForInitializedResponder {
1262    type ControlHandle = ControllerControlHandle;
1263
1264    fn control_handle(&self) -> &ControllerControlHandle {
1265        &self.control_handle
1266    }
1267
1268    fn drop_without_shutdown(mut self) {
1269        // Safety: drops once, never accessed again due to mem::forget
1270        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1271        // Prevent Drop from running (which would shut down the channel)
1272        std::mem::forget(self);
1273    }
1274}
1275
1276impl ControllerListenForInitializedResponder {
1277    /// Sends a response to the FIDL transaction.
1278    ///
1279    /// Sets the channel to shutdown if an error occurs.
1280    pub fn send(self) -> Result<(), fidl::Error> {
1281        let _result = self.send_raw();
1282        if _result.is_err() {
1283            self.control_handle.shutdown();
1284        }
1285        self.drop_without_shutdown();
1286        _result
1287    }
1288
1289    /// Similar to "send" but does not shutdown the channel if an error occurs.
1290    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
1291        let _result = self.send_raw();
1292        self.drop_without_shutdown();
1293        _result
1294    }
1295
1296    fn send_raw(&self) -> Result<(), fidl::Error> {
1297        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
1298            (),
1299            self.tx_id,
1300            0x3454fbf05fcf10ef,
1301            fidl::encoding::DynamicFlags::empty(),
1302        )
1303    }
1304}
1305
1306mod internal {
1307    use super::*;
1308}
fidl_fuchsia_cobalt/fidl_fuchsia_cobalt.rs

fidl_fuchsia_cobalt/
fidl_fuchsia_cobalt.rs
