water 0.7.22-alpha

A Rust library that provides a thread-safe distributed message sending facility supporting synchronous and asynchronous I/O across process and machine boundaries. It also uses nets which allow message broadcasts to all, groups, or specific endpoints which eliminates the need for tons of individual channels to interconnect threads. It also provides inter-process communication using a more restricted raw message type.
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

use std::sync::Mutex;
use std::mem::transmute;
use std::rt::heap::deallocate;
use std::mem::size_of;
use std::mem::align_of;
use std::sync::MutexGuard;
use std::ptr;

/*
struct Internal {
    a:  uint,
    b:  uint,
}


impl Drop for Internal {
    fn drop(&mut self) {
        println!("dropped");
    }
}

fn main() {
    let m = AllocMutex::new(Internal {
        a: 0,
        b: 0,
    });
    
    m.lock().a = 3;
    m.lock().b = 3;
    
    // optional (leak memory)
    m.free();
}
*/

pub struct AllocMutex<T: Send> {
    m:  Mutex<*mut T>,
}

unsafe impl<T: Send + 'static> Send for AllocMutex<T> { }

impl<T: Send> AllocMutex<T> {
    pub fn new(t: T) -> AllocMutex<T> {
        let r: *mut T = unsafe { transmute(box t) };
    
        AllocMutex {
            m:  Mutex::new(r),
        }
    }
    
    pub fn lock(&self) -> MutexGuard<&mut T> {
        unsafe { transmute( self.m.lock() ) }
    }

    pub fn rawmutref(&self) -> *mut T {
        *self.m.lock()
    }
    
    pub fn mutref(&self) -> &mut T {
        unsafe { transmute( (*self.m.lock()) ) }
    }
    
    pub fn free(&self) {
        unsafe {
            let o: *mut T = transmute(self.mutref());
            drop(ptr::read(&(*o)));
            deallocate(o as *mut u8, size_of::<T>(), align_of::<T>());
        }
    }
}