abs_buff 0.1.1

ABStraction of BUFFered IO
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use core::{
    future::{self, Future, IntoFuture, Ready},
    marker::PhantomData,
    ops::DerefMut,
    pin::Pin,
};

use abs_sync::cancellation::{TrCancellationToken, TrIntoFutureMayCancel};

/// Buffer owner that will lend the slice for writing.
pub trait TrBuffWriter<T: Clone = u8> {
    type BuffMut<'a>: DerefMut<Target = [T]> where Self: 'a;

    type Err;

    type WriteAsync<'a>: TrIntoFutureMayCancel<'a, MayCancelOutput =
        Result<Self::BuffMut<'a>, Self::Err>>
    where
        Self: 'a;

    fn can_write(&mut self) -> bool;

    fn write_async(&mut self, length: usize) -> Self::WriteAsync<'_>;
}

/// A dummy writer as placeholder in generic types.
pub struct DisabledBuffWriter<T: Clone>(PhantomData<[T; 0]>);

impl<T: Clone> TrBuffWriter<T> for DisabledBuffWriter<T> {
    type BuffMut<'a> = &'a mut [T] where Self: 'a;

    type Err = ();

    type WriteAsync<'a> = WriteAsync<'a, T> where Self: 'a;

    fn can_write(&mut self) -> bool {
        false
    }

    fn write_async(&mut self, _: usize) -> Self::WriteAsync<'_> {
        self::WriteAsync::new()
    }
}

pub struct WriteAsync<'a, T>(PhantomData<&'a mut DisabledBuffWriter<T>>)
where
    T: Clone;

impl<'a, T: Clone> WriteAsync<'a, T> {
    fn new() -> Self {
        WriteAsync(PhantomData)
    }
}

impl<'a, T: Clone> IntoFuture for WriteAsync<'a, T> {
    type IntoFuture = Ready<Self::Output>;
    type Output = Result<&'a mut [T], ()>;

    fn into_future(self) -> Self::IntoFuture {
        future::ready(Result::Err(()))
    }
}

impl<'a, T: Clone> TrIntoFutureMayCancel<'a> for WriteAsync<'a, T> {
    type MayCancelOutput = <<Self as IntoFuture>::IntoFuture as Future>::Output;

    fn may_cancel_with<C>(
        self,
        cancel: Pin<&'a mut C>,
    ) -> impl Future<Output = Self::MayCancelOutput>
    where
        C: TrCancellationToken,
    {
        let _ = cancel;
        future::ready(Result::Err(()))
    }
}