intercomm 0.1.1

Asynchronous inter-component communication library
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

use std::any::Any;

type Value = dyn Any + Send + Sync;

pub(crate) struct UntypedBox {
    inner: Box<Value>,
}

impl UntypedBox {
    pub(crate) fn new<T: Send + Sync + 'static>(value: T) -> Self {
        Self {
            inner: Box::new(value),
        }
    }

    #[allow(dead_code)]
    /// Safety: T must be some type that used in UntypedBox::new
    pub(crate) unsafe fn consume<T>(self) -> Box<T> {
        let raw = Box::into_raw(self.inner);
        Box::from_raw(raw as *mut T)
    }

    /// Safety: T must be some type that used in UntypedBox::new
    pub(crate) unsafe fn get_ref<T>(&self) -> &T {
        &*(self.inner.as_ref() as *const Value as *const T)
    }

    #[allow(dead_code)]
    /// Safety: T must be some type that used in UntypedBox::new
    pub(crate) unsafe fn get_mut<T>(&mut self) -> &mut T {
        &mut *(self.inner.as_mut() as *mut Value as *mut T)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn untyped_box() {
        let mut b = UntypedBox::new(0i32);
        assert_eq!(unsafe { *b.get_ref::<i32>() }, 0);

        unsafe {
            *b.get_mut::<i32>() = 1;
        }
        assert_eq!(unsafe { *b.get_ref::<i32>() }, 1);

        let b = unsafe { b.consume::<i32>() };
        assert_eq!(*b, 1);
    }
}