use crate::decoder::Decoder;
use crate::transport::Transport;
use crossbeam_channel::Receiver;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread;
const DEFAULT_BUFFER_SIZE: usize = 1024;
const DEFAULT_CHANNEL_CAPACITY: usize = 100;
pub struct ConnectionWorker<P: Send + 'static> {
receiver: Receiver<P>,
running: Arc<AtomicBool>,
}
impl<P: Send + 'static> ConnectionWorker<P> {
pub fn spawn<T, D>(transport: T, decoder: D) -> Self
where
T: Transport + 'static,
D: Decoder<Output = P> + 'static,
{
Self::spawn_with_capacity(
transport,
decoder,
DEFAULT_BUFFER_SIZE,
DEFAULT_CHANNEL_CAPACITY,
)
}
pub fn spawn_with_capacity<T, D>(
mut transport: T,
mut decoder: D,
buffer_size: usize,
channel_capacity: usize,
) -> Self
where
T: Transport + 'static,
D: Decoder<Output = P> + 'static,
{
let (sender, receiver) = crossbeam_channel::bounded(channel_capacity);
let running = Arc::new(AtomicBool::new(true));
let running_clone = Arc::clone(&running);
thread::spawn(move || {
let mut buffer = vec![0u8; buffer_size];
while running_clone.load(Ordering::Relaxed) {
match transport.read(&mut buffer) {
Ok(bytes_read) if bytes_read > 0 => {
if let Some(packet) = decoder.decode(&buffer[..bytes_read]) {
let _ = sender.try_send(packet);
}
}
_ => {
thread::sleep(std::time::Duration::from_millis(5));
}
}
}
});
Self { receiver, running }
}
pub fn try_recv(&self) -> Option<P> {
self.receiver.try_recv().ok()
}
pub fn drain_latest(&self) -> Option<P> {
let mut latest = None;
while let Ok(pkt) = self.receiver.try_recv() {
latest = Some(pkt);
}
latest
}
}
impl<P: Send + 'static> Drop for ConnectionWorker<P> {
fn drop(&mut self) {
self.running.store(false, Ordering::Relaxed);
}
}