hala-io 0.1.6

hala asynchronous io programming primitive types
Documentation 
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

use std::{future::Future, io, task::Context};

use std::task::Poll;

/// A future object which will suspend current task when `F` returns error [`WouldBlock`](io::ErrorKind::WouldBlock)
pub struct WouldBlock<F> {
    f: F,
}

impl<F, R> Future for WouldBlock<F>
where
    F: FnMut(&mut Context<'_>) -> io::Result<R> + Unpin,
{
    type Output = io::Result<R>;

    fn poll(mut self: std::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        match (self.f)(cx) {
            Ok(r) => Poll::Ready(Ok(r)),
            Err(err) if err.kind() == io::ErrorKind::WouldBlock => Poll::Pending,
            Err(err) => Poll::Ready(Err(err)),
        }
    }
}

/// Create a new future task that will suspend current task when `F` return error [`WouldBlock`](io::ErrorKind::WouldBlock)
pub fn would_block<F, R>(f: F) -> WouldBlock<F>
where
    F: FnMut(&mut Context<'_>) -> io::Result<R> + Unpin,
{
    WouldBlock { f }
}

/// Call function `F` once and convert returns error [`WouldBlock`](io::ErrorKind::WouldBlock) to Poll [`Pending`](Poll::Pending)
pub fn poll_would_block<F, R>(f: F) -> Poll<io::Result<R>>
where
    F: FnOnce() -> io::Result<R> + Unpin,
{
    match f() {
        Ok(r) => Poll::Ready(Ok(r)),
        Err(err) if err.kind() == io::ErrorKind::WouldBlock => Poll::Pending,
        Err(err) => Poll::Ready(Err(err)),
    }
}