abs_sync 0.2.0

ABStraction of SYNchronization
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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use core::{
    future::{Future, IntoFuture}, marker::PhantomData, mem::MaybeUninit, ops::{AsyncFnOnce, Try}
};

use crate::cancellation::{NonCancellableToken, TrMayCancel};

/// An convenient future to implement `IntoFuture` for `TrIntoFutureMayCancel`
/// that will not actually being cancelled, and that the output will differs
/// (but deducible) from the cancellable version.
pub struct NeverCancelAsync<'a, T>
where
    T: TrMayCancel<'a, MayCancelOutput: Try>,
{
    task_: MaybeUninit<T>,
    _use_: PhantomData<&'a ()>,
}

impl<'a, T> NeverCancelAsync<'a, T>
where
    T: TrMayCancel<'a, MayCancelOutput: Try>,
{
    pub fn new(task: T) -> Self {
        NeverCancelAsync {
            task_: MaybeUninit::new(task),
            _use_: PhantomData,
        }
    }

    async fn run_without_cancel(self) -> T::MayCancelOutput {
        let task = unsafe { self.task_.assume_init_read() };
        let cancel = NonCancellableToken::pinned();
        task.may_cancel_with(cancel).await
    }
}

impl<'a, T> AsyncFnOnce<()> for NeverCancelAsync<'a, T>
where
    T: TrMayCancel<'a, MayCancelOutput: Try>,
{
    type CallOnceFuture = impl Future<Output = Self::Output>;
    type Output = T::MayCancelOutput;

    extern "rust-call" fn async_call_once(
        self,
        _: (),
    ) -> Self::CallOnceFuture {
        self.run_without_cancel()
    }
}

impl<'a, T> IntoFuture for NeverCancelAsync<'a, T>
where
    T: TrMayCancel<'a, MayCancelOutput: Try>,
{
    type IntoFuture = <Self as AsyncFnOnce<()>>::CallOnceFuture;
    type Output = <Self::IntoFuture as Future>::Output;

    fn into_future(self) -> Self::IntoFuture {
        self()
    }
}