async-utils 0.1.1

nothing to see here yet :)
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

use ::std::ops::{Deref, DerefMut};

pub trait MutexFamily {
    type Mutex<T: Send + 'static>: Mutex<T>;

    fn new<T: Send + 'static>(val: T) -> Self::Mutex<T>;
}

pub trait Mutex<T>: Send + Sync + 'static {
    type Guard<'a>: Guard<T>
    where
        Self: 'a,
        T: 'a;

    fn lock(&self) -> Self::Guard<'_>;
}

pub trait Guard<T>: Deref<Target = T> + DerefMut {}

pub type MutexGuardType<'a, M, T> = <<M as MutexFamily>::Mutex<T> as Mutex<T>>::Guard<'a>;

#[cfg(feature = "parking_lot")]
pub use self::parking_lot::ParkingLotMutex;
pub use self::std::StdMutex;

mod std {
    use super::{Guard, Mutex, MutexFamily};

    pub struct StdMutex;

    impl MutexFamily for StdMutex {
        type Mutex<T: Send + 'static> = std::sync::Mutex<T>;

        #[inline]
        fn new<T: Send + 'static>(val: T) -> Self::Mutex<T> {
            std::sync::Mutex::new(val)
        }
    }

    impl<T: Send + 'static> Mutex<T> for std::sync::Mutex<T> {
        type Guard<'a> = std::sync::MutexGuard<'a, T>
        where
            T: 'a;

        #[inline]
        fn lock(&self) -> Self::Guard<'_> {
            self.lock().unwrap()
        }
    }

    impl<'a, T: 'a> Guard<T> for std::sync::MutexGuard<'a, T> {}
}

#[cfg(feature = "parking_lot")]
mod parking_lot {
    use super::{Guard, Mutex, MutexFamily};

    pub struct ParkingLotMutex;

    impl MutexFamily for ParkingLotMutex {
        type Mutex<T: Send + 'static> = parking_lot::Mutex<T>;

        #[inline]
        fn new<T: Send + 'static>(val: T) -> Self::Mutex<T> {
            parking_lot::Mutex::new(val)
        }
    }

    impl<T: Send + 'static> Mutex<T> for parking_lot::Mutex<T> {
        type Guard<'a> = parking_lot::MutexGuard<'a, T>
        where
            T: 'a;

        #[inline]
        fn lock(&self) -> Self::Guard<'_> {
            self.lock()
        }
    }

    impl<'a, T: 'a> Guard<T> for parking_lot::MutexGuard<'a, T> {}
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    #[cfg(feature = "parking_lot")]
    use crate::sync::mutex::ParkingLotMutex;
    use crate::sync::mutex::{Mutex, MutexFamily, StdMutex};

    struct Data {
        a: usize,
    }

    #[test]
    fn mutex() {
        fn generic<M: MutexFamily>() {
            let data = Arc::new(M::new(Data { a: 0 }));

            {
                let data = Arc::clone(&data);
                std::thread::spawn(move || {
                    let mut guard = data.lock();
                    guard.a += 1;
                })
                .join()
                .unwrap();
            }

            let mut guard = data.lock();
            guard.a += 1;

            assert_eq!(guard.a, 2);
        }

        generic::<StdMutex>();

        #[cfg(feature = "parking_lot")]
        generic::<ParkingLotMutex>();
    }
}