ferment-sys 0.2.14

Syntax tree morphing of FFI-compatible stuff
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

use std::cell::{RefCell, Ref, RefMut};
use std::rc::Rc;
use std::sync::{Arc, Mutex, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};

pub trait SharedAccess {
    type Item;
    type ImmutableAccess: ?Sized;
    type MutableAccess: ?Sized;

    fn clone_container(&self) -> Self where Self: Sized;

    fn access<F, R>(&self, f: F) -> R
        where
            F: FnOnce(&Self::ImmutableAccess) -> R;

    #[allow(unused)]
    fn access_mut<F, R>(&self, f: F) -> R where F: FnOnce(&Self::MutableAccess) -> R;
}
impl<T: 'static> SharedAccess for Rc<RefCell<T>> {
    type Item = T;
    type ImmutableAccess = Ref<'static, T>;
    type MutableAccess = RefMut<'static, T>;

    fn clone_container(&self) -> Self {
        Rc::clone(self)
    }

    fn access<F, R>(&self, f: F) -> R where F: FnOnce(&Self::ImmutableAccess) -> R {
        let borrowed = self.borrow();
        f(unsafe { std::mem::transmute::<&Ref<T>, &Ref<'static, T>>(&borrowed) })
    }

    fn access_mut<F, R>(&self, f: F) -> R where F: FnOnce(&Self::MutableAccess) -> R {
        let borrowed_mut = self.borrow_mut();
        f(unsafe { std::mem::transmute::<&RefMut<T>, &RefMut<'static, T>>(&borrowed_mut) })
    }
}

impl<T: 'static> SharedAccess for Arc<Mutex<T>> {
    type Item = T;
    type ImmutableAccess = MutexGuard<'static, T>;
    type MutableAccess = MutexGuard<'static, T>;

    fn clone_container(&self) -> Self {
        Arc::clone(self)
    }

    fn access<F, R>(&self, f: F) -> R where F: FnOnce(&Self::ImmutableAccess) -> R {
        let lock = self.lock().unwrap();
        let result = f(unsafe { std::mem::transmute::<&MutexGuard<T>, &MutexGuard<'static, T>>(&lock) });
        drop(lock);
        result
    }

    fn access_mut<F, R>(&self, f: F) -> R where F: FnOnce(&Self::MutableAccess) -> R {
        let lock = self.lock().unwrap();
        let result = f(unsafe { std::mem::transmute::<&MutexGuard<T>, &MutexGuard<'static, T>>(&lock) });
        drop(lock);
        result
    }
}

impl<T: 'static> SharedAccess for Arc<RwLock<T>> {
    type Item = T;
    type ImmutableAccess = RwLockReadGuard<'static, T>;
    type MutableAccess = RwLockWriteGuard<'static, T>;

    fn clone_container(&self) -> Self {
        Arc::clone(self)
    }

    fn access<F, R>(&self, f: F) -> R where F: FnOnce(&Self::ImmutableAccess) -> R {
        let lock = self.read().unwrap();
        let result = f(unsafe { std::mem::transmute::<&RwLockReadGuard<T>, &RwLockReadGuard<'static, T>>(&lock) });
        drop(lock);
        result
    }

    fn access_mut<F, R>(&self, f: F) -> R where F: FnOnce(&Self::MutableAccess) -> R {
        let lock = self.write().unwrap();
        let result = f(unsafe { std::mem::transmute::<&RwLockWriteGuard<T>, &RwLockWriteGuard<'static, T>>(&lock) });
        drop(lock);
        result
    }
}