forensic_rs/
channel.rs

1#[derive(Clone)]
2pub struct Sender<T> {
3    inner: InnerSender<T>,
4}
5#[derive(Clone)]
6pub enum InnerSender<T> {
7    SyncSender(std::sync::mpsc::SyncSender<T>),
8    Sender(std::sync::mpsc::Sender<T>)
9}
10
11pub struct Receiver<T> {
12    inner: std::sync::mpsc::Receiver<T>,
13}
14
15#[derive(PartialEq, Eq, Clone, Copy)]
16pub struct SendError<T>(pub T);
17
18#[derive(PartialEq, Eq, Clone, Copy)]
19pub struct RecvError;
20
21#[derive(PartialEq, Eq, Clone, Copy, Debug)]
22pub enum TryRecvError {
23    /// This **channel** is currently empty, but the **Sender**(s) have not yet
24    /// disconnected, so data may yet become available.
25    Empty,
26
27    /// The **channel**'s sending half has become disconnected, and there will
28    /// never be any more data received on it.
29    Disconnected,
30}
31#[derive(PartialEq, Eq, Clone, Copy, Debug)]
32pub enum RecvTimeoutError {
33    /// This **channel** is currently empty, but the **Sender**(s) have not yet
34    /// disconnected, so data may yet become available.
35    Timeout,
36    /// The **channel**'s sending half has become disconnected, and there will
37    /// never be any more data received on it.
38    Disconnected,
39}
40
41#[derive(PartialEq, Eq, Clone, Copy)]
42pub enum TrySendError<T> {
43    Full(T),
44    Disconnected(T)
45}
46
47
48
49impl<T> Sender<T> {
50    fn new_sync(sender : std::sync::mpsc::SyncSender<T>) -> Self {
51        Self {
52            inner : InnerSender::SyncSender(sender)
53        }
54    }
55    fn new(sender : std::sync::mpsc::Sender<T>) -> Self {
56        Self {
57            inner : InnerSender::Sender(sender)
58        }
59    }
60
61    pub fn send(&self, msg : T) -> Result<(), SendError<T>> {
62        let res = match &self.inner {
63            InnerSender::SyncSender(s) => s.send(msg),
64            InnerSender::Sender(s) => s.send(msg),
65        };
66        match res {
67            Ok(_) => Ok(()),
68            Err(e) => Err(e.into())
69        }
70    }
71
72    pub fn try_send(&self, msg : T) -> Result<(), TrySendError<T>> {
73        match &self.inner {
74            InnerSender::SyncSender(s) => match s.try_send(msg) {
75                Ok(_) => Ok(()),
76                Err(e) => Err(e.into())
77            },
78            InnerSender::Sender(s) => match s.send(msg) {
79                Ok(_) => Ok(()),
80                Err(e) => Err(e.into())
81            },
82        }
83    }
84}
85
86impl<T> Receiver<T> {
87    fn new(receiver : std::sync::mpsc::Receiver<T>) -> Self {
88        Self {
89            inner : receiver
90        }
91    }
92    pub fn recv(&self) -> Result<T, RecvError> {
93        match self.inner.recv() {
94            Ok(v) => Ok(v),
95            Err(e) => Err(e.into())
96        }
97    }
98    pub fn try_recv(&self) -> Result<T, TryRecvError> {
99        match self.inner.try_recv() {
100            Ok(v) => Ok(v),
101            Err(e) => Err(e.into())
102        }
103    }
104    pub fn recv_timeout(&self, duration : std::time::Duration) -> Result<T, RecvTimeoutError> {
105        match self.inner.recv_timeout(duration) {
106            Ok(v) => Ok(v),
107            Err(e) => Err(e.into())
108        }
109    }
110}
111
112pub fn sync_channel<T>(bound : usize) -> (Sender<T>, Receiver<T>) {
113    let (sender, receiver) = std::sync::mpsc::sync_channel(bound);
114    (Sender::new_sync(sender), Receiver::new(receiver))
115}
116
117pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
118    let (sender, receiver) = std::sync::mpsc::channel();
119    (Sender::new(sender), Receiver::new(receiver))
120}
121
122
123impl<T> From<std::sync::mpsc::TrySendError<T>> for TrySendError<T> {
124    fn from(value: std::sync::mpsc::TrySendError<T>) -> Self {
125        match value {
126            std::sync::mpsc::TrySendError::Full(v) => TrySendError::Full(v),
127            std::sync::mpsc::TrySendError::Disconnected(v) => TrySendError::Disconnected(v),
128        }
129    }
130}
131impl<T> From<std::sync::mpsc::SendError<T>> for TrySendError<T> {
132    fn from(value: std::sync::mpsc::SendError<T>) -> Self {
133        TrySendError::Disconnected(value.0)
134    }
135}
136
137impl<T> From<std::sync::mpsc::SendError<T>> for SendError<T> {
138    fn from(value: std::sync::mpsc::SendError<T>) -> Self {
139        SendError(value.0)
140    }
141}
142
143impl From<std::sync::mpsc::RecvError> for RecvError {
144    fn from(_value: std::sync::mpsc::RecvError) -> Self {
145        RecvError
146    }
147}
148
149impl From<std::sync::mpsc::TryRecvError> for TryRecvError {
150    fn from(value: std::sync::mpsc::TryRecvError) -> Self {
151        match value {
152            std::sync::mpsc::TryRecvError::Disconnected => TryRecvError::Disconnected,
153            std::sync::mpsc::TryRecvError::Empty => TryRecvError::Empty
154        }
155    }
156}
157impl From<std::sync::mpsc::RecvTimeoutError> for RecvTimeoutError {
158    fn from(value: std::sync::mpsc::RecvTimeoutError) -> Self {
159        match value {
160            std::sync::mpsc::RecvTimeoutError::Disconnected => RecvTimeoutError::Disconnected,
161            std::sync::mpsc::RecvTimeoutError::Timeout => RecvTimeoutError::Timeout
162        }
163    }
164}
forensic_rs/channel.rs

forensic_rs/
channel.rs
