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

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

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

/// Buffer owner that will lend slice for peeking (without moving cursor).
pub trait TrBuffPeeker<T: Clone = u8> {
    type BuffRef<'a>: Deref<Target = [T]> where Self: 'a;

    type Err;

    type PeekAsync<'a>: TrIntoFutureMayCancel<'a, MayCancelOutput =
        Result<Self::BuffRef<'a>, Self::Err>>
    where
        Self: 'a;

    fn can_peek(&mut self, skip: usize) -> bool;

    fn peek_async(&mut self, skip: usize) -> Self::PeekAsync<'_>;
}

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

impl<T: Clone> TrBuffPeeker<T> for DisabledBuffPeeker<T> {
    type BuffRef<'a> = &'a [T] where Self: 'a;

    type Err = ();

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

    fn can_peek(&mut self, _: usize) -> bool {
        false
    }

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

pub struct PeekAsync<'a, T: Clone>(PhantomData<&'a mut DisabledBuffPeeker<T>>);

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

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

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

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

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