ruyi 0.1.6

An event-driven framework for non-blocking, asynchronous I/O in Rust
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

use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread::JoinHandle;
use std::net::SocketAddr;

use channel::err::SendError;
use channel::spsc::SyncSender;
use net::TcpStream;

pub struct Worker {
    tx: Option<SyncSender<(TcpStream, SocketAddr)>>,
    join_handle: Option<JoinHandle<()>>,
    conn_count: Arc<AtomicUsize>,
}

impl Worker {
    #[inline]
    pub fn new(
        tx: SyncSender<(TcpStream, SocketAddr)>,
        join_handle: JoinHandle<()>,
        conn_count: Arc<AtomicUsize>,
    ) -> Self {
        Worker {
            tx: Some(tx),
            join_handle: Some(join_handle),
            conn_count,
        }
    }

    #[inline]
    pub fn send(
        &self,
        conn: TcpStream,
        peer_addr: SocketAddr,
    ) -> Result<(), SendError<(TcpStream, SocketAddr)>> {
        match self.tx.as_ref() {
            Some(tx) => tx.send((conn, peer_addr)),
            None => ::unreachable(),
        }
    }

    #[inline]
    pub fn conn_count(&self) -> usize {
        self.conn_count.load(Ordering::Relaxed)
    }

    #[inline]
    pub fn inc_conn_count(&self) {
        self.conn_count.fetch_add(1, Ordering::Relaxed);
    }
}

impl Drop for Worker {
    fn drop(&mut self) {
        self.tx = None;
        if let Some(join_handle) = self.join_handle.take() {
            join_handle.join().ok();
        }
    }
}