kasino 0.1.0

Framework for implementing sharded concurrent datastructures.
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

#![expect(unused_imports)]
#![expect(clippy::disallowed_modules)]

#[cfg(all(not(loom), not(shuttle)))]
pub(crate) use core_::*;
#[cfg(loom)]
pub(crate) use loom_::*;
#[cfg(shuttle)]
pub(crate) use shuttle_::*;

#[cfg(shuttle)]
mod shuttle_ {
    pub(crate) use shuttle::{
        hint,
        sync::{Arc, Weak, atomic},
        thread,
    };
}

#[cfg(loom)]
mod loom_ {
    // no Weak in loom
    pub(crate) use std::sync::Weak;

    pub(crate) use loom::{
        hint,
        sync::{Arc, atomic},
        thread,
    };
}

#[cfg(all(not(loom), not(shuttle)))]
mod core_ {
    #[cfg(any(feature = "alloc", test))]
    pub(crate) use alloc::sync::{Arc, Weak};
    pub(crate) use core::hint;
    #[cfg(any(feature = "std", test))]
    pub(crate) use std::thread;

    pub(crate) use portable_atomic as atomic;
}

#[cfg(test)]
pub(crate) use mutex_impls::*;

#[cfg(test)]
mod mutex_impls {

    #[cfg(all(not(loom), feature = "std"))]
    pub(crate) use mutex::*;
    #[cfg(all(not(loom), not(shuttle), not(feature = "std")))]
    pub(crate) use spin::{Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};

    #[cfg(all(not(loom), not(shuttle), feature = "std"))]
    mod mutex {
        pub(crate) use std::sync::MutexGuard;

        #[derive(Debug, Default)]
        /// wraps std::sync::Mutex
        pub(crate) struct Mutex<T>(std::sync::Mutex<T>);

        impl<T> Mutex<T> {
            #[expect(dead_code)]
            /// Constructs a new Mutex
            pub(crate) const fn new(t: T) -> Self {
                Self(std::sync::Mutex::new(t))
            }

            /// locks the Mutex. This calls unwrap() on the internal Mutex, panicking on poison.
            pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
                self.0.lock().unwrap()
            }

            /// tries to lock the mutex
            #[expect(dead_code)]
            pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
                self.0.try_lock().ok()
            }
        }
    }

    #[cfg(loom)]
    pub(crate) use mutex::*;

    #[cfg(loom)]
    mod mutex {
        use core::ops::{Deref, DerefMut};

        pub(crate) use loom::sync::{Arc, MutexGuard};

        #[derive(Debug, Default)]
        /// wraps a loom:::sync::Mutext
        pub(crate) struct Mutex<T>(loom::sync::Mutex<T>);

        impl<T> Mutex<T> {
            /// constructs a new Mutex
            pub(crate) fn new(t: T) -> Self {
                Self(loom::sync::Mutex::new(t))
            }

            /// locks the mutex. unwraps poison
            pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
                self.0.lock().unwrap()
            }

            /// tries to lock the mutex
            #[allow(dead_code)]
            pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
                self.0.try_lock().ok()
            }
        }
    }

    #[cfg(shuttle)]
    pub(crate) use mutex::*;

    #[cfg(shuttle)]
    mod mutex {
        use core::ops::{Deref, DerefMut};

        pub(crate) use shuttle::sync::{Arc, MutexGuard};

        #[derive(Debug, Default)]
        /// wraps a shuttle::sync::mutex
        pub(crate) struct Mutex<T>(shuttle::sync::Mutex<T>);

        impl<T> Mutex<T> {
            #[expect(dead_code)]
            /// constructs a new mutex
            pub(crate) const fn new(t: T) -> Self {
                Self(shuttle::sync::Mutex::new(t))
            }

            /// locks the mutex. unwrapsp poison
            pub(crate) fn lock(&self) -> MutexGuard<'_, T> {
                self.0.lock().unwrap()
            }

            /// tries to lock the mutex
            #[expect(dead_code)]
            pub(crate) fn try_lock(&self) -> Option<MutexGuard<'_, T>> {
                self.0.try_lock().ok()
            }
        }
    }
}