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
|
//! Utilities to cause interruptions in common traits, like Read/Write and Iterator.
use std::{
io,
sync::atomic::{AtomicBool, Ordering},
};
/// A wrapper for an inner iterator which will check for interruptions on each iteration, stopping the iteration when
/// that is requested.
pub struct Iter<'a, I> {
/// The actual iterator to yield elements from.
pub inner: I,
should_interrupt: &'a AtomicBool,
}
impl<'a, I> Iter<'a, I>
where
I: Iterator,
{
/// Create a new iterator over `inner` which checks for interruptions on each iteration on `should_interrupt`.
///
/// Note that this means the consumer of the iterator data should also be able to access `should_interrupt` and
/// consider it when producing the final result to avoid claiming success even though the operation is only partially
/// complete.
pub fn new(inner: I, should_interrupt: &'a AtomicBool) -> Self {
Iter {
inner,
should_interrupt,
}
}
}
impl<'a, I> Iterator for Iter<'a, I>
where
I: Iterator,
{
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
if self.should_interrupt.load(Ordering::Relaxed) {
return None;
}
self.inner.next()
}
}
/// A wrapper for an inner iterator which will check for interruptions on each iteration.
pub struct IterWithErr<'a, I, EFN> {
/// The actual iterator to yield elements from.
pub inner: I,
make_err: Option<EFN>,
should_interrupt: &'a AtomicBool,
}
impl<'a, I, EFN, E> IterWithErr<'a, I, EFN>
where
I: Iterator,
EFN: FnOnce() -> E,
{
/// Create a new iterator over `inner` which checks for interruptions on each iteration and calls `make_err()` to
/// signal an interruption happened, causing no further items to be iterated from that point on.
pub fn new(inner: I, make_err: EFN, should_interrupt: &'a AtomicBool) -> Self {
IterWithErr {
inner,
make_err: Some(make_err),
should_interrupt,
}
}
}
impl<'a, I, EFN, E> Iterator for IterWithErr<'a, I, EFN>
where
I: Iterator,
EFN: FnOnce() -> E,
{
type Item = Result<I::Item, E>;
fn next(&mut self) -> Option<Self::Item> {
self.make_err.as_ref()?;
if self.should_interrupt.load(Ordering::Relaxed) {
return self.make_err.take().map(|f| Err(f()));
}
match self.inner.next() {
Some(next) => Some(Ok(next)),
None => {
self.make_err = None;
None
}
}
}
}
/// A wrapper for implementors of [`std::io::Read`] or [`std::io::BufRead`] with interrupt support.
///
/// It fails a [read][`std::io::Read::read`] while an interrupt was requested.
pub struct Read<'a, R> {
/// The actual implementor of [`std::io::Read`] to which interrupt support will be added.
pub inner: R,
/// The flag to trigger interruption
pub should_interrupt: &'a AtomicBool,
}
impl<'a, R> io::Read for Read<'a, R>
where
R: io::Read,
{
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if self.should_interrupt.load(Ordering::Relaxed) {
return Err(std::io::Error::new(std::io::ErrorKind::Other, "Interrupted"));
}
self.inner.read(buf)
}
}
impl<'a, R> io::BufRead for Read<'a, R>
where
R: io::BufRead,
{
fn fill_buf(&mut self) -> io::Result<&[u8]> {
self.inner.fill_buf()
}
fn consume(&mut self, amt: usize) {
self.inner.consume(amt)
}
}
|
