jlrs 0.23.0

jlrs provides bindings to the Julia C API that enable Julia code to be called from Rust and more.
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

use std::{
    borrow::Borrow,
    collections::HashMap,
    hash::{BuildHasher, Hash, RandomState},
    sync::atomic::{AtomicBool, Ordering},
};

use fnv::FnvBuildHasher;
use rustc_hash::FxBuildHasher;

use crate::{gc_safe::GcSafeRwLock, memory::gc::gc_safe};

pub(crate) struct Cache<K, V, S = RandomState> {
    map: GcSafeRwLock<HashMap<K, V, S>>,
    dirty: AtomicBool,
}

pub(crate) type FnvCache<K, V> = Cache<K, V, FnvBuildHasher>;

pub(crate) const fn new_fnv_cache<K, V>() -> FnvCache<K, V> {
    let hasher = FnvBuildHasher::new();
    Cache {
        map: GcSafeRwLock::new(HashMap::with_hasher(hasher)),
        dirty: AtomicBool::new(false),
    }
}

pub(crate) type FxCache<K, V> = Cache<K, V, FxBuildHasher>;

pub(crate) const fn new_fx_cache<K, V>() -> FxCache<K, V> {
    let hasher = FxBuildHasher;
    Cache {
        map: GcSafeRwLock::new(HashMap::with_hasher(hasher)),
        dirty: AtomicBool::new(false),
    }
}

pub(crate) trait CacheMap<'a, K: 'a + Eq + Hash, V: 'a + Clone, S: BuildHasher> {
    fn insert(&self, key: K, value: V) -> Option<V>;

    fn get<Q>(&'a self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Hash + Eq + ?Sized;

    fn clear_dirty(&self);

    fn is_dirty(&self) -> bool;

    unsafe fn map(&'a self, func: impl Fn(V));
}

impl<'a, K: 'a + Eq + Hash, V: 'a + Clone> CacheMap<'a, K, V, FxBuildHasher> for FxCache<K, V> {
    fn insert(&self, key: K, value: V) -> Option<V> {
        let res = unsafe { gc_safe(|| self.map.write().insert(key, value)) };
        self.dirty.store(true, Ordering::Relaxed);
        res
    }

    fn get<Q>(&'a self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Hash + Eq + ?Sized,
    {
        self.map.read().get(key).cloned()
    }

    fn clear_dirty(&self) {
        self.dirty.store(false, Ordering::Relaxed);
    }

    fn is_dirty(&self) -> bool {
        self.dirty.load(Ordering::Relaxed)
    }

    unsafe fn map(&'a self, func: impl Fn(V)) {
        unsafe {
            self.map
                .data_ptr()
                .as_ref()
                .unwrap()
                .iter()
                .map(|(_, v)| func(v.clone()))
                .collect::<()>()
        }
    }
}

impl<'a, K: 'a + Eq + Hash, V: 'a + Clone> CacheMap<'a, K, V, FnvBuildHasher> for FnvCache<K, V> {
    fn insert(&self, key: K, value: V) -> Option<V> {
        let res = self.map.write().insert(key, value);
        self.dirty.store(true, Ordering::Relaxed);
        res
    }

    fn get<Q>(&'a self, key: &Q) -> Option<V>
    where
        K: Borrow<Q>,
        Q: Hash + Eq + ?Sized,
    {
        self.map.read().get(key).cloned()
    }

    fn clear_dirty(&self) {
        self.dirty.store(false, Ordering::Relaxed);
    }

    fn is_dirty(&self) -> bool {
        self.dirty.load(Ordering::Relaxed)
    }

    unsafe fn map(&'a self, func: impl Fn(V)) {
        unsafe {
            self.map
                .data_ptr()
                .as_ref()
                .unwrap()
                .iter()
                .map(|(_, v)| func(v.clone()))
                .collect::<()>()
        }
    }
}

unsafe impl<K, V, S> Send for Cache<K, V, S> {}
unsafe impl<K, V, S> Sync for Cache<K, V, S> {}