async-fifo 0.6.5

MPMC & oneshot channels with (a)sync API
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
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use alloc::vec::Vec;

/// Dyn-Compatible subset of [`Storage`] trait
///
/// Automatically derived for every Storage implementor.
pub trait InternalStorageApi<T> {
    fn bounds(&self) -> (Option<usize>, Option<usize>);
    fn insert(&mut self, index: usize, item: T);
    fn reserve(&mut self, len: usize);
}

/// Backing storage for pull operations
pub trait Storage<T>: Sized {
    type Output;

    /// Insert an item into a storage slot
    ///
    /// `index` is the index of this push operation
    /// since the call to `Consumer::try_recv_*`.
    fn insert(&mut self, index: usize, item: T);

    /// Called to seal the storage after all negociated
    /// items have been received
    ///
    /// The negociated number of items is available as `pushed`.
    fn finish(self, pushed: usize) -> Result<Self::Output, Self>;

    #[allow(unused_variables)]
    /// Pre-allocate space for `len` additional items
    fn reserve(&mut self, len: usize) {}

    /// Specify the number of items that this storage
    /// can handle
    ///
    /// The value must be returned as (minimum, maximum).
    fn bounds(&self) -> (Option<usize>, Option<usize>) {
        (None, None)
    }
}

impl<T, S: Storage<T>> InternalStorageApi<T> for S {
    fn bounds(&self) -> (Option<usize>, Option<usize>) {
        S::bounds(self)
    }

    fn insert(&mut self, index: usize, item: T) {
        S::insert(self, index, item)
    }

    fn reserve(&mut self, len: usize) {
        S::reserve(self, len)
    }
}

impl<T> Storage<T> for &mut Vec<T> {
    type Output = usize;

    fn reserve(&mut self, len: usize) {
        Vec::reserve(self, len);
    }

    fn insert(&mut self, _index: usize, item: T) {
        Vec::push(self, item);
    }

    fn finish(self, pushed: usize) -> Result<Self::Output, Self> {
        match pushed {
            0 => Err(self),
            _ => Ok(pushed),
        }
    }
}

impl<T> Storage<T> for &mut [T] {
    type Output = ();

    fn insert(&mut self, index: usize, item: T) {
        self[index] = item;
    }

    fn bounds(&self) -> (Option<usize>, Option<usize>) {
        (Some(self.len()), Some(self.len()))
    }

    fn finish(self, pushed: usize) -> Result<Self::Output, Self> {
        match pushed {
            0 => Err(self),
            _ => Ok(()),
        }
    }
}

#[doc(hidden)]
pub struct TmpArray<const N: usize, T> {
    pub inner: [Option<T>; N],
}

impl<const N: usize, T> Default for TmpArray<N, T> {
    fn default() -> Self {
        Self { 
            inner: core::array::from_fn(|_| None),
        }
    }
}

impl<const N: usize, T> Storage<T> for TmpArray<N, T> {
    type Output = [T; N];

    fn insert(&mut self, index: usize, item: T) {
        self.inner[index] = Some(item);
    }

    fn bounds(&self) -> (Option<usize>, Option<usize>) {
        (Some(N), Some(N))
    }

    fn finish(self, pushed: usize) -> Result<Self::Output, Self> {
        match pushed {
            0 => Err(self),
            _ => Ok(self.inner.map(Option::unwrap)),
        }
    }
}

impl<T> Storage<T> for Option<T> {
    type Output = T;

    fn insert(&mut self, _index: usize, item: T) {
        *self = Some(item);
    }

    fn bounds(&self) -> (Option<usize>, Option<usize>) {
        (Some(1), Some(1))
    }

    fn finish(self, _pushed: usize) -> Result<Self::Output, Self> {
        self.ok_or(None)
    }
}