barrage 0.2.3

An async broadcast channel
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

// These modules are a hack to get around IntelliJ not yet understanding mutually exclusive feature
// gates as mutually exclusive

mod rwlock {
    #[cfg(windows)]
    pub use std::sync::*;
    #[cfg(not(windows))]
    pub use spin::rwlock::*;
}

pub type RwLock<T> = rwlock::RwLock<T>;
pub type WriteGuard<'a, T> = rwlock::RwLockWriteGuard<'a, T>;
pub type ReadGuard<'a, T> = rwlock::RwLockReadGuard<'a, T>;

#[cfg(not(windows))]
pub fn wait_lock<'a, T, F, R>(lock: &'a RwLock<T>, try_lock: F) -> R
    where F: Fn(&'a RwLock<T>) -> Option<R>
{
    #[allow(unused_variables)]
    let mut i = 4;

    loop {
        for _ in 0..10 {
            if let Some(guard) = try_lock(lock) {
                return guard;
            }
            std::thread::yield_now();
        }

        std::thread::sleep(std::time::Duration::from_nanos(1 << i));

        i += 1;
    }
}

#[cfg(not(windows))]
pub fn lock_write<T>(lock: &RwLock<T>) -> WriteGuard<'_, T> {
    wait_lock(lock, |l| l.try_write())
}

#[cfg(not(windows))]
pub fn lock_read<T>(lock: &RwLock<T>) -> ReadGuard<'_, T> {
    wait_lock(lock, |l| l.try_read())
}

#[cfg(windows)]
pub fn lock_write<T>(lock: &RwLock<T>) -> WriteGuard<'_, T> {
    lock.write().unwrap()
}

#[cfg(windows)]
pub fn lock_read<T>(lock: &RwLock<T>) -> ReadGuard<'_, T> {
    lock.read().unwrap()
}