/
select_bias.rs
220 lines (203 loc) · 6.32 KB
/
select_bias.rs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
use super::assert_stream;
use crate::stream::{Fuse, StreamExt};
use core::pin::Pin;
use futures_core::stream::{FusedStream, Stream};
use futures_core::task::{Context, Poll};
use pin_project_lite::pin_project;
/// Type to tell [`SelectBias`] which stream to poll next.
#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
pub enum PollNext {
/// Poll the first stream.
Left,
/// Poll the second stream.
Right,
}
impl PollNext {
/// Toggle the value and return the old one.
pub fn toggle(&mut self) -> Self {
let old = *self;
match self {
PollNext::Left => *self = PollNext::Right,
PollNext::Right => *self = PollNext::Left,
}
old
}
}
impl Default for PollNext {
fn default() -> Self {
PollNext::Left
}
}
pin_project! {
/// Stream for the [`select_bias()`] function. See function docs for details.
#[derive(Debug)]
#[must_use = "streams do nothing unless polled"]
pub struct SelectBias<St1, St2, Clos, State> {
#[pin]
stream1: Fuse<St1>,
#[pin]
stream2: Fuse<St2>,
state: State,
clos: Clos,
}
}
/// This function will attempt to pull items from both streams. You provide a
/// closure to tell the [`SelectBias`] which stream to poll. The closure can
/// store state on `SelectBias` to which it will receive a `&mut` on every
/// invocation. This allows basing the strategy on prior choices.
///
/// After one of the two input stream completes, the remaining one will be
/// polled exclusively. The returned stream completes when both input
/// streams have completed.
///
/// Note that this function consumes both streams and returns a wrapped
/// version of them.
///
/// ## Examples
///
/// ### Priority
/// This example shows how to always prioritize the left stream.
///
/// ```rust
///
/// # futures::executor::block_on(async {
/// use futures_util::stream::{ select_bias, PollNext, StreamExt };
/// use futures::stream::repeat;
///
/// let left = repeat(1);
/// let right = repeat(2);
///
/// // We don't need any state, so lets make it an empty tuple.
/// // We must provide some type here, as there is no way for the compiler
/// // to infer it.
/// let prio_left = |_: &mut ()| PollNext::Left;
///
/// let mut out = select_bias(left, right, prio_left);
///
/// for _ in 0..100 {
/// // Whenever we poll out, we will alwasy get `1`.
/// assert_eq!(1, out.select_next_some().await);
/// }
///
/// });
/// ```
///
/// ### Round Robin
/// This example shows how to select from both streams round robin.
///
/// ```rust
///
/// # futures::executor::block_on(async {
/// use futures_util::stream::{ select_bias, PollNext, StreamExt };
/// use futures::stream::repeat;
///
/// let left = repeat(1);
/// let right = repeat(2);
///
/// // We don't need any state, so lets make it an empty tuple.
/// let rrobin = |last: &mut PollNext| last.toggle();
///
/// let mut out = select_bias(left, right, rrobin);
///
/// for _ in 0..100 {
/// // We should be alternating now.
/// assert_eq!(1, out.select_next_some().await);
/// assert_eq!(2, out.select_next_some().await);
/// }
///
/// });
/// ```
pub fn select_bias<St1, St2, Clos, State>(
stream1: St1,
stream2: St2,
which: Clos,
) -> SelectBias<St1, St2, Clos, State>
where
St1: Stream,
St2: Stream<Item = St1::Item>,
Clos: FnMut(&mut State) -> PollNext,
State: Default,
{
assert_stream::<St1::Item, _>(SelectBias {
stream1: stream1.fuse(),
stream2: stream2.fuse(),
state: Default::default(),
clos: which,
})
}
impl<St1, St2, Clos, State> SelectBias<St1, St2, Clos, State> {
/// Acquires a reference to the underlying streams that this combinator is
/// pulling from.
pub fn get_ref(&self) -> (&St1, &St2) {
(self.stream1.get_ref(), self.stream2.get_ref())
}
/// Acquires a mutable reference to the underlying streams that this
/// combinator is pulling from.
///
/// Note that care must be taken to avoid tampering with the state of the
/// stream which may otherwise confuse this combinator.
pub fn get_mut(&mut self) -> (&mut St1, &mut St2) {
(self.stream1.get_mut(), self.stream2.get_mut())
}
/// Acquires a pinned mutable reference to the underlying streams that this
/// combinator is pulling from.
///
/// Note that care must be taken to avoid tampering with the state of the
/// stream which may otherwise confuse this combinator.
pub fn get_pin_mut(self: Pin<&mut Self>) -> (Pin<&mut St1>, Pin<&mut St2>) {
let this = self.project();
(this.stream1.get_pin_mut(), this.stream2.get_pin_mut())
}
/// Consumes this combinator, returning the underlying streams.
///
/// Note that this may discard intermediate state of this combinator, so
/// care should be taken to avoid losing resources when this is called.
pub fn into_inner(self) -> (St1, St2) {
(self.stream1.into_inner(), self.stream2.into_inner())
}
}
impl<St1, St2, Clos, State> FusedStream for SelectBias<St1, St2, Clos, State>
where
St1: Stream,
St2: Stream<Item = St1::Item>,
Clos: FnMut(&mut State) -> PollNext,
{
fn is_terminated(&self) -> bool {
self.stream1.is_terminated() && self.stream2.is_terminated()
}
}
impl<St1, St2, Clos, State> Stream for SelectBias<St1, St2, Clos, State>
where
St1: Stream,
St2: Stream<Item = St1::Item>,
Clos: FnMut(&mut State) -> PollNext,
{
type Item = St1::Item;
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<St1::Item>> {
let this = self.project();
match (this.clos)(this.state) {
PollNext::Left => poll_inner(this.stream1, this.stream2, cx),
PollNext::Right => poll_inner(this.stream2, this.stream1, cx),
}
}
}
fn poll_inner<St1, St2>(
a: Pin<&mut St1>,
b: Pin<&mut St2>,
cx: &mut Context<'_>,
) -> Poll<Option<St1::Item>>
where
St1: Stream,
St2: Stream<Item = St1::Item>,
{
let a_done = match a.poll_next(cx) {
Poll::Ready(Some(item)) => return Poll::Ready(Some(item)),
Poll::Ready(None) => true,
Poll::Pending => false,
};
match b.poll_next(cx) {
Poll::Ready(Some(item)) => Poll::Ready(Some(item)),
Poll::Ready(None) if a_done => Poll::Ready(None),
Poll::Ready(None) | Poll::Pending => Poll::Pending,
}
}