singly 0.1.1

Lightweight "not" thread safe singleton but it depend on the usage though
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
61
62
63
64

//! This is where the magic

use core::{any::Any, cell::UnsafeCell, ptr::NonNull};

use alloc::boxed::Box;

#[derive(Debug)]
/// Very not safe wrapper to allow bypass safety thread safety
pub struct Inner {
    inner: UnsafeCell<NonNull<dyn Any>>,
}

impl Inner {
    /// Creating and instance of Inner
    ///
    /// ## Panic
    ///
    /// Will if the pointer is not valid
    pub fn new<T: Any>(val: T) -> Self {
        Self {
            inner: UnsafeCell::new(NonNull::new(Box::into_raw(Box::new(val))).unwrap()),
        }
    }

    /// Get the reference of content of Inner
    ///
    /// # Panic
    ///
    /// Not sure what will make this thing panic
    pub fn get(&self) -> &dyn Any {
        unsafe { self.inner.get().as_ref().map(|ptr| &*ptr.as_ptr()).unwrap() }
    }

    /// Get the mutable reference of content of Inner
    ///
    /// # Panic
    ///
    /// Not sure what will make this thing panic
    pub fn get_mut(&self) -> &mut dyn Any {
        unsafe {
            self.inner
                .get()
                .as_mut()
                .map(|ptr| &mut *ptr.as_ptr())
                .unwrap()
        }
    }
}

unsafe impl Sync for Inner {}
unsafe impl Send for Inner {}

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

    #[test]
    fn test_if_value_is_correct() {
        let inner = Inner::new(10);

        assert_eq!(inner.get().downcast_ref::<i32>().unwrap(), &10);
        assert_eq!(inner.get_mut().downcast_ref::<i32>().unwrap(), &10);
    }
}