water 0.3.10-alpha

A Rust library that provides a thread-safe distributed message sending facility supporting synchronous and asynchronous I/O.
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

use std::sync::Arc;
use std::sync::Mutex;
use std::intrinsics::transmute;

use net::Net;

pub type TCPLISTENER = Arc<RacyCell<TCPListener>>;
pub type TCPCONNECTOR = Arc<RacyCell<TCPConnector>>;

pub struct RacyCell<T> {
    t:      T
}

impl<T> Deref<T> for RacyCell<T> {
    fn deref<'a>(&'a self) -> &'a T {
        &self.t
    }
}

// Trying a new design here. It is dangerous to have to maintain
// a seperate inner structure just to gain clone functionality.
// Since Arc provides it we can use it, but Arc restricts the deref
// to immutable. So this is my workaround to being able to use Arc.
impl<T> RacyCell<T> {
    pub fn new(t: T) -> RacyCell<T> {
        RacyCell {t: t}
    }

    // This breaks mutability/immutability because it lets you take
    // anything that is immutable and produce an mutable reference.
    fn mutref(&self) -> &mut T {
        let p: &mut RacyCell<T>;

        p = unsafe { transmute(self) };

        &mut p.t
    }
}

pub struct TCPListener {
    net:    Net,
}
pub struct TCPConnector {
    net:    Net,
}

impl TCPListener {
    pub fn thread(s: TCPLISTENER) {

    }

    pub fn new(net: &Net, host: String, port: u16) -> TCPLISTENER {
        let n = Arc::new(RacyCell::new(TCPListener { net: net.clone() }));
        let nclone = n.clone();
        spawn(move || { TCPListener::thread(nclone) });

        n
    }

}

impl TCPConnector {
    pub fn thread(s: TCPCONNECTOR) {

    }

    pub fn new(net: &Net, host: String, port: u16) -> TCPCONNECTOR {
        let n = Arc::new(RacyCell::new(TCPConnector { net: net.clone() }));
        let nclone = n.clone();
        spawn(move || { TCPConnector::thread(nclone)});

        n
    }
}