hexga_core 0.0.11-beta.56

Basic set of functionalities common to all hexga crate
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

use super::*;

/// Multi threaded read only singleton, where the value is initialized at compile time.
pub type SingletonOnce<T> = SingletonOf<OnceLock<T>>;
/// Multi threaded read only singleton, where the value is initialized from a static fn / lambda at runtime.
pub type SingletonOnceLazy<T> = SingletonOf<LazyLock<T>>;

// Wasm is single threaded right now, so this is ok.
#[cfg(all(target_arch = "wasm32", not(target_feature = "atomics")))]
mod single_thread
{
    use super::*;

    unsafe impl<T> Sync for SingletonOnce<T> {}
    unsafe impl<T> Send for SingletonOnce<T> {}

    unsafe impl<T> Sync for SingletonOnceLazy<T> {}
    unsafe impl<T> Send for SingletonOnceLazy<T> {}
}

impl<T> SingletonOnce<T>
{
    pub const fn uninit() -> Self { Self::from_guard(OnceLock::new()) }

    pub const fn new() -> Self { Self::uninit() }
}

impl<T> Debug for SingletonOnce<T>
where
    T: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult
    {
        match self.try_get()
        {
            Ok(guard) => write!(f, "{:?}", guard),
            Err(e) => write!(f, "SingletonOnce<{}> can't be read: {:?}", std::any::type_name::<T>(), e),
        }
    }
}

impl<T> Guarded<T> for SingletonOnce<T>
{
    type Guard<'a>
        = &'a T
    where
        Self: 'a;

    #[inline]
    #[track_caller]
    fn get<'a>(&'a self) -> Self::Guard<'a>
    {
        match self.guarded.get()
        {
            Some(guard) => guard,
            None =>
            {
                panic!("SingletonOnce<{}> not initialized", std::any::type_name::<T>())
            }
        }
    }
    type Error<'a>
        = ()
    where
        Self: 'a;

    fn try_get<'a>(&'a self) -> Result<Self::Guard<'a>, Self::Error<'a>> { self.guarded.get().ok_or(()) }
}

impl<T> SingletonOnceable<T> for SingletonOnce<T>
{
    fn init_from_fn<'a, F>(&'a self, init: F) -> Result<Self::Guard<'a>, F>
    where
        F: FnOnce() -> T,
    {
        Ok(self.guarded.get_or_init(init))
    }
}

impl_singleton_methods_get!(SingletonOnce);

impl<T> SingletonOnceLazy<T>
{
    pub const fn new(f: fn() -> T) -> Self { Self::from_guard(LazyLock::new(f)) }

    pub const fn uninit() -> Self { Self::from_guard(LazyLock::new(|| panic!("SingletonOnceLazy<{}> not initialized", std::any::type_name::<T>()))) }
}

impl<T> Debug for SingletonOnceLazy<T>
where
    T: Debug,
{
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult
    {
        match self.try_get()
        {
            Ok(guard) => write!(f, "{:?}", guard),
            Err(e) => write!(f, "SingletonOnceLazy<{}> can't be read: {:?}", std::any::type_name::<T>(), e),
        }
    }
}

impl<T> Guarded<T> for SingletonOnceLazy<T>
{
    type Guard<'a>
        = &'a T
    where
        Self: 'a;

    #[track_caller]
    fn get<'a>(&'a self) -> Self::Guard<'a> { &self.guarded }

    type Error<'a>
        = std::convert::Infallible
    where
        Self: 'a;

    fn try_get<'a>(&'a self) -> Result<Self::Guard<'a>, Self::Error<'a>> { Ok(&self.guarded) }
}
impl_singleton_methods_get!(SingletonOnceLazy);