anylock 0.1.6

AnyLock Polymorphic Locks
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

use std::{marker::PhantomData, sync::Arc};

use crate::AnyLock;

#[derive(Default, Debug)]
struct MyWrapper<T, Inner>
where
    T: std::fmt::Debug,
    Inner: AnyLock<T>,
{
    inner: Arc<Inner>,
    _phantom: PhantomData<T>,
}

impl<T, Lock> MyWrapper<T, Lock>
where
    T: std::fmt::Debug,
    Lock: AnyLock<T>,
{
    fn new(inner: T) -> Self {
        Self {
            inner: Arc::new(Lock::new(inner)),
            _phantom: PhantomData,
        }
    }
}

#[test]
pub fn std_mutex() {
    let x = MyWrapper::<String, crate::StdMutex<String>>::new("Hello".into());
    println!("{:#?}", x);
    println!("{:?}", x.inner.read());
}

#[test]
pub fn core_refcell() {
    let x = MyWrapper::<String, crate::CoreRefCell<String>>::new("Hello".into());
    println!("{:#?}", x);
    println!("{:?}", x.inner.read());
}

#[test]
pub fn parking_lot_mutex() {
    let x = MyWrapper::<String, crate::ParkingLotMutex<String>>::new("Hello".into());
    println!("{:?}", x.inner.read());
}

#[test]
pub fn tokio_sync_mutex() {
    let x = MyWrapper::<String, crate::TokioMutex<String>>::new("Hello".into());
    println!("{:#?}", x);
    println!("{:?}", x.inner.read());
}

#[test]
pub fn std_rwlock() {
    let x = MyWrapper::<String, crate::StdRwLock<String>>::new("Hello".into());
    println!("{:#?}", x);
    println!("{:?}", x.inner.read());
}

#[test]
pub fn parking_lot_rwlock_read() {
    let x = MyWrapper::<String, crate::ParkingLotRwLock<String>>::new("Hello".into());
    println!("{:#?}", x);
    println!("{:?}", x.inner.read());
}

#[test]
pub fn parking_lot_rwlock_write() {
    let x = MyWrapper::<String, crate::ParkingLotRwLock<String>>::new("Hello".into());
    *x.inner.write() = "World".into();
    println!("{:#?}", x);
    println!("{:?}", x.inner.read());
}

#[test]
pub fn tokio_sync_rwlock_read() {
    let x = MyWrapper::<String, crate::TokioRwLock<String>>::new("Hello".into());
    println!("{:#?}", x);
    println!("{:?}", x.inner.read());
}

#[test]
pub fn tokio_sync_rwlock_write() {
    let x = MyWrapper::<String, crate::TokioRwLock<String>>::new("Hello".into());
    *x.inner.write() = "World".into();
    println!("{:#?}", x);
    println!("{:?}", x.inner.write());
}

#[tokio::test]
async fn tokio_async_mutex() {
    let x = MyWrapper::<String, crate::TokioMutex<String>>::new("Hello".into());
    *x.inner.async_write().await = "World".into();
    println!("{:#?}", x);
    println!("{:?}", x.inner.async_read().await);
}

#[tokio::test]
async fn tokio_async_rwlock_write() {
    let x = MyWrapper::<String, crate::TokioRwLock<String>>::new("Hello".into());
    *x.inner.async_write().await = "World".into();
    println!("{:#?}", x);
    println!("{:?}", x.inner.async_read().await);
}