refs 0.51.0

My vision of reference counting and resources management designed for GUI applications.
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use std::{
    any::type_name,
    fmt::{Debug, Formatter},
    ops::{Deref, DerefMut},
    ptr::NonNull,
};

use log::error;

/// `Rglica` is a thin wrapper around a raw, non-owning pointer (`NonNull<T>`).
///
/// This struct provides C++ style raw pointer behavior in Rust.
///
/// # Safety
/// - Not safe at all.
///
/// # Notes
/// - Use with caution — misuse can cause undefined behavior.
/// - Designed for performance-sensitive code.
///
/// Very unsafe — avoid using unless absolutely necessary.
pub struct Rglica<T: ?Sized> {
    pub ptr: Option<NonNull<T>>,
}

unsafe impl<T: ?Sized> Send for Rglica<T> {}

impl<T: ?Sized> Copy for Rglica<T> {}

impl<T: ?Sized> Clone for Rglica<T> {
    fn clone(&self) -> Rglica<T> {
        *self
    }
}

impl<T: ?Sized> Rglica<T> {
    pub const fn const_default() -> Self {
        Self { ptr: None }
    }

    pub fn from_ref(rf: &T) -> Rglica<T> {
        Self {
            ptr: Some(NonNull::from(rf)),
        }
    }

    pub fn is_null(&self) -> bool {
        self.ptr.is_none()
    }

    pub fn is_ok(&self) -> bool {
        self.ptr.is_some()
    }

    pub fn as_ptr(&self) -> *mut T {
        self.ptr.unwrap().as_ptr()
    }

    pub fn get(&mut self) -> Option<&mut T> {
        if self.is_ok() {
            self.deref_mut().into()
        } else {
            None
        }
    }
}

impl<T: ?Sized> Deref for Rglica<T> {
    type Target = T;
    fn deref(&self) -> &T {
        if self.is_null() {
            error!("Null Rglica: {}", std::any::type_name::<T>());
            // backtrace();
            panic!("Null Rglica: {}", std::any::type_name::<T>());
        }
        unsafe { self.ptr.unwrap().as_ref() }
    }
}

impl<T: ?Sized> DerefMut for Rglica<T> {
    fn deref_mut(&mut self) -> &mut T {
        if self.is_null() {
            error!("Null Rglica: {}", std::any::type_name::<T>());
            // backtrace();
            panic!("Null Rglica: {}", std::any::type_name::<T>());
        }
        unsafe { self.ptr.unwrap().as_mut() }
    }
}

impl<T: ?Sized> Default for Rglica<T> {
    fn default() -> Rglica<T> {
        Self { ptr: None }
    }
}

impl<T: ?Sized> Debug for Rglica<T> {
    default fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        type_name::<T>().fmt(f)
    }
}

impl<T: ?Sized + Debug> Debug for Rglica<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if self.is_null() {
            return self.ptr.fmt(f);
        }
        self.deref().fmt(f)
    }
}

#[cfg(test)]
mod test {
    use std::ops::{Deref, DerefMut};

    use crate::Rglica;

    struct NoDebug;

    #[test]
    #[should_panic(expected = "Null Rglica: i32")]
    fn null_rglica() {
        let null = Rglica::<i32>::default();
        assert!(null.is_null());
        assert_eq!(null.is_ok(), false);
        _ = null.deref();
    }

    #[test]
    #[should_panic(expected = "Null Rglica: i32")]
    fn null_rglica_mut() {
        let mut null = Rglica::<i32>::default();
        assert!(null.is_null());
        assert_eq!(null.is_ok(), false);
        _ = null.deref_mut();
    }

    #[test]
    fn rglica_misc() {
        let five = 5;

        let five = &five;

        let mut val = Rglica::from_ref(five);

        assert_eq!(val.is_null(), false);
        assert_eq!(val.is_ok(), true);

        assert_eq!("5", &format!("{val:?}"));

        let cloned = val.clone();

        assert_eq!(val.deref(), cloned.deref());

        let get = val.get().unwrap();

        *get = 10;

        assert_eq!(*val.deref(), 10);

        assert_eq!(
            "\"refs::rglica::test::NoDebug\"",
            format!("{:?}", Rglica::from_ref(&NoDebug))
        );

        assert_eq!("None", format!("{:?}", Rglica::<i32>::default()));

        assert_eq!(None, Rglica::<i32>::default().get());
    }
}