twilight_standby/
future.rs

1//! Futures and streams returned by [`Standby`].
2//!
3//! [`Standby`]: super::Standby
4
5use futures_core::Stream;
6use std::{
7    error::Error,
8    fmt::{Display, Formatter, Result as FmtResult},
9    future::Future,
10    pin::Pin,
11    task::{Context, Poll},
12};
13use tokio::sync::{
14    mpsc::UnboundedReceiver as MpscReceiver,
15    oneshot::{error::RecvError, Receiver},
16};
17use twilight_model::{
18    application::interaction::Interaction,
19    gateway::{
20        event::Event,
21        payload::incoming::{MessageCreate, ReactionAdd},
22    },
23};
24
25/// Future canceled due to Standby being dropped.
26#[derive(Debug)]
27pub struct Canceled(RecvError);
28
29impl Canceled {
30    /// Consume the error, returning the source error if there is any.
31    pub fn into_source(self) -> Option<Box<dyn Error + Send + Sync>> {
32        Some(Box::new(self.0))
33    }
34}
35
36impl Display for Canceled {
37    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
38        Display::fmt(&self.0, f)
39    }
40}
41
42impl Error for Canceled {
43    fn source(&self) -> Option<&(dyn Error + 'static)> {
44        Some(&self.0)
45    }
46}
47
48/// The future returned from [`Standby::wait_for_event`].
49///
50/// [`Standby::wait_for_event`]: crate::Standby::wait_for_event
51#[derive(Debug)]
52#[must_use = "futures do nothing unless you `.await` or poll them"]
53pub struct WaitForEventFuture {
54    /// Receiver half of the oneshot channel.
55    pub(crate) rx: Receiver<Event>,
56}
57
58impl Future for WaitForEventFuture {
59    type Output = Result<Event, Canceled>;
60
61    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
62        Pin::new(&mut self.rx).poll(cx).map_err(Canceled)
63    }
64}
65
66/// The stream returned from [`Standby::wait_for_event_stream`].
67///
68/// [`Standby::wait_for_event_stream`]: crate::Standby::wait_for_event_stream
69#[derive(Debug)]
70#[must_use = "streams do nothing unless you poll them"]
71pub struct WaitForEventStream {
72    /// Receiver half of the MPSC channel.
73    pub(crate) rx: MpscReceiver<Event>,
74}
75
76impl Stream for WaitForEventStream {
77    type Item = Event;
78
79    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
80        self.rx.poll_recv(cx)
81    }
82}
83
84/// The future returned from [`Standby::wait_for`].
85///
86/// [`Standby::wait_for`]: crate::Standby::wait_for
87#[derive(Debug)]
88#[must_use = "futures do nothing unless you `.await` or poll them"]
89pub struct WaitForGuildEventFuture {
90    /// Receiver half of the oneshot channel.
91    pub(crate) rx: Receiver<Event>,
92}
93
94impl Future for WaitForGuildEventFuture {
95    type Output = Result<Event, Canceled>;
96
97    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
98        Pin::new(&mut self.rx).poll(cx).map_err(Canceled)
99    }
100}
101
102/// The stream returned from [`Standby::wait_for_stream`].
103///
104/// [`Standby::wait_for_stream`]: crate::Standby::wait_for_stream
105#[derive(Debug)]
106#[must_use = "streams do nothing unless you poll them"]
107pub struct WaitForGuildEventStream {
108    /// Receiver half of the MPSC channel.
109    pub(crate) rx: MpscReceiver<Event>,
110}
111
112impl Stream for WaitForGuildEventStream {
113    type Item = Event;
114
115    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
116        self.rx.poll_recv(cx)
117    }
118}
119
120/// The future returned from [`Standby::wait_for_message`].
121///
122/// [`Standby::wait_for_message`]: crate::Standby::wait_for_message
123#[derive(Debug)]
124#[must_use = "futures do nothing unless you `.await` or poll them"]
125pub struct WaitForMessageFuture {
126    /// Receiver half of the oneshot channel.
127    pub(crate) rx: Receiver<MessageCreate>,
128}
129
130impl Future for WaitForMessageFuture {
131    type Output = Result<MessageCreate, Canceled>;
132
133    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
134        Pin::new(&mut self.rx).poll(cx).map_err(Canceled)
135    }
136}
137
138/// The stream returned from [`Standby::wait_for_message_stream`].
139///
140/// [`Standby::wait_for_message_stream`]: crate::Standby::wait_for_message_stream
141#[derive(Debug)]
142#[must_use = "streams do nothing unless you poll them"]
143pub struct WaitForMessageStream {
144    /// Receiver half of the MPSC channel.
145    pub(crate) rx: MpscReceiver<MessageCreate>,
146}
147
148impl Stream for WaitForMessageStream {
149    type Item = MessageCreate;
150
151    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
152        self.rx.poll_recv(cx)
153    }
154}
155
156/// The future returned from [`Standby::wait_for_reaction`].
157///
158/// [`Standby::wait_for_reaction`]: crate::Standby::wait_for_reaction
159#[derive(Debug)]
160#[must_use = "futures do nothing unless you `.await` or poll them"]
161pub struct WaitForReactionFuture {
162    /// Receiver half of the oneshot channel.
163    pub(crate) rx: Receiver<ReactionAdd>,
164}
165
166impl Future for WaitForReactionFuture {
167    type Output = Result<ReactionAdd, Canceled>;
168
169    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
170        Pin::new(&mut self.rx).poll(cx).map_err(Canceled)
171    }
172}
173
174/// The stream returned from [`Standby::wait_for_reaction_stream`].
175///
176/// [`Standby::wait_for_reaction_stream`]: crate::Standby::wait_for_reaction_stream
177#[derive(Debug)]
178#[must_use = "streams do nothing unless you poll them"]
179pub struct WaitForReactionStream {
180    /// Receiver half of the MPSC channel.
181    pub(crate) rx: MpscReceiver<ReactionAdd>,
182}
183
184impl Stream for WaitForReactionStream {
185    type Item = ReactionAdd;
186
187    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
188        self.rx.poll_recv(cx)
189    }
190}
191
192/// The future returned from [`Standby::wait_for_component`].
193///
194/// [`Standby::wait_for_component`]: crate::Standby::wait_for_component
195#[derive(Debug)]
196#[must_use = "futures do nothing unless you `.await` or poll them"]
197pub struct WaitForComponentFuture {
198    /// Receiver half of the oneshot channel.
199    pub(crate) rx: Receiver<Interaction>,
200}
201
202impl Future for WaitForComponentFuture {
203    type Output = Result<Interaction, Canceled>;
204
205    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
206        Pin::new(&mut self.rx).poll(cx).map_err(Canceled)
207    }
208}
209
210/// The stream returned from [`Standby::wait_for_component_stream`].
211///
212/// [`Standby::wait_for_component_stream`]: crate::Standby::wait_for_component_stream
213#[derive(Debug)]
214#[must_use]
215pub struct WaitForComponentStream {
216    /// Receiver half of the MPSC channel.
217    pub(crate) rx: MpscReceiver<Interaction>,
218}
219
220impl Stream for WaitForComponentStream {
221    type Item = Interaction;
222
223    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
224        self.rx.poll_recv(cx)
225    }
226}
227
228#[cfg(test)]
229mod tests {
230    use super::{
231        WaitForEventFuture, WaitForEventStream, WaitForGuildEventFuture, WaitForGuildEventStream,
232        WaitForMessageFuture, WaitForMessageStream, WaitForReactionFuture, WaitForReactionStream,
233    };
234    use futures_core::Stream;
235    use static_assertions::assert_impl_all;
236    use std::{fmt::Debug, future::Future};
237
238    assert_impl_all!(WaitForEventFuture: Debug, Future, Send, Sync);
239    assert_impl_all!(WaitForGuildEventFuture: Debug, Future, Send, Sync);
240    assert_impl_all!(WaitForMessageFuture: Debug, Future, Send, Sync);
241    assert_impl_all!(WaitForReactionFuture: Debug, Future, Send, Sync);
242    assert_impl_all!(WaitForEventStream: Debug, Stream, Send, Sync);
243    assert_impl_all!(WaitForGuildEventStream: Debug, Stream, Send, Sync);
244    assert_impl_all!(WaitForMessageStream: Debug, Stream, Send, Sync);
245    assert_impl_all!(WaitForReactionStream: Debug, Stream, Send, Sync);
246}
twilight_standby/future.rs

twilight_standby/
future.rs
