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

use leak_playground_std::marker::Forget;

pub mod rendezvous;
pub use rendezvous::rendezvous;

/// Create a bounded channel.
pub fn bounded<T: Forget>(cap: usize) -> (Sender<T>, Receiver<T>) {
    let (tx, rx) = flume::bounded(cap);
    (Sender { inner: tx }, Receiver { inner: rx })
}

/// Create a bounded channel for the unforgettable parameter type `T`.
///
/// # Safety
///
/// `T` must not take ownership over itself.
pub unsafe fn bounded_unchecked<T>(cap: usize) -> (Sender<T>, Receiver<T>) {
    let (tx, rx) = flume::bounded(cap);
    (Sender { inner: tx }, Receiver { inner: rx })
}

/// Create an unbounded channel.
pub fn unbounded<T: Forget>() -> (Sender<T>, Receiver<T>) {
    let (tx, rx) = flume::unbounded();
    (Sender { inner: tx }, Receiver { inner: rx })
}

/// Create an unbounded channel for the unforgettable parameter type `T`.
///
/// # Safety
///
/// `T` must not take ownership over itself.
pub unsafe fn unbounded_unchecked<T>() -> (Sender<T>, Receiver<T>) {
    let (tx, rx) = flume::unbounded();
    (Sender { inner: tx }, Receiver { inner: rx })
}

pub struct Sender<T> {
    inner: flume::Sender<T>,
}

impl<T> Sender<T> {
    pub fn send(&self, msg: T) -> Result<(), flume::SendError<T>> {
        self.inner.send(msg)
    }

    pub fn try_send(&self, msg: T) -> Result<(), flume::TrySendError<T>> {
        self.inner.try_send(msg)
    }

    pub fn send_async(&self, item: T) -> flume::r#async::SendFut<T> {
        self.inner.send_async(item)
    }

    pub fn into_send_async<'a>(self, item: T) -> flume::r#async::SendFut<'a, T> {
        self.inner.into_send_async(item)
    }
}

pub struct Receiver<T> {
    inner: flume::Receiver<T>,
}

impl<T> Receiver<T> {
    pub fn recv(&self) -> Result<T, flume::RecvError> {
        self.inner.recv()
    }

    pub fn try_recv(&self) -> Result<T, flume::TryRecvError> {
        self.inner.try_recv()
    }

    pub fn recv_async(&self) -> flume::r#async::RecvFut<'_, T> {
        self.inner.recv_async()
    }

    pub fn into_recv_async<'a>(self) -> flume::r#async::RecvFut<'a, T> {
        self.inner.into_recv_async()
    }
}

unsafe impl<T: Forget> Forget for Sender<T> {}
unsafe impl<T: Forget> Forget for Receiver<T> {}