wrc 0.2.0

A thread-safe weighted reference counting smart-pointer for Rust.
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
127
128

use std::sync::Mutex;
use std::ops::Deref;
use std::cmp::Ordering;
use std::fmt;
use std::hash::{Hash, Hasher};
use weight::Weight;

// The WRC `Inner` value uses `Mutex<usize>` to store the total weight value,
// meaning that mutations of the weight are thread-safe.
pub struct Inner<T: ?Sized> {
    weight: Mutex<usize>,
    data: T,
}

impl<T> Inner<T> {
    #[inline]
    pub fn new(data: T, starting_weight: usize) -> Inner<T> {
        Inner {
            weight: Mutex::new(starting_weight),
            data: data,
        }
    }

    #[inline]
    fn data(&self) -> &T {
        &self.data
    }
}

unsafe impl<T: ?Sized + Sync + Send> Send for Inner<T> {}
unsafe impl<T: ?Sized + Sync + Send> Sync for Inner<T> {}

impl<T: ?Sized> Weight for Inner<T> {
    fn add_weight(&self, weight: usize) -> Option<usize> {
        let mut existing_weight = self.weight.lock().expect("Unable to acquire WRC inner lock");
        let new_weight = existing_weight.checked_add(weight);
        match new_weight {
            Some(weight) => {
                *existing_weight = weight;
                Some(weight)
            }
            None => None,
        }
    }

    fn drop_weight(&self, weight: usize) -> Option<usize> {
        let mut existing_weight = self.weight.lock().expect("Unable to acquire WRC inner lock");
        let new_weight = existing_weight.checked_sub(weight);
        match new_weight {
            Some(weight) => {
                *existing_weight = weight;
                Some(weight)
            }
            None => None,
        }
    }

    fn get_weight(&self) -> usize {
        self.weight.lock().expect("Unable to acquire WRC inner lock").clone()
    }
}

impl<T> Deref for Inner<T> {
    type Target = T;

    #[inline]
    fn deref(&self) -> &T {
        &self.data()
    }
}

impl<T> fmt::Display for Inner<T> where T: fmt::Display {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(self.data(), f)
    }
}

impl<T> fmt::Debug for Inner<T> where T: fmt::Debug {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(self.data(), f)
    }
}

impl<T: ?Sized + PartialEq> PartialEq for Inner<T> {
    fn eq(&self, other: &Inner<T>) ->  bool {
        self.data == other.data
    }

    fn ne(&self, other: &Inner<T>) -> bool {
        self.data != other.data
    }
}

impl<T: PartialOrd> PartialOrd for Inner<T> {
    fn partial_cmp(&self, other: &Inner<T>) -> Option<Ordering> {
        self.data.partial_cmp(&other.data)
    }

    fn lt(&self, other: &Inner<T>) -> bool {
        self.data < other.data
    }

    fn le(&self, other: &Inner<T>) -> bool {
        self.data <= other.data
    }

    fn gt(&self, other: &Inner<T>) -> bool {
        self.data > other.data
    }

    fn ge(&self, other: &Inner<T>) -> bool {
        self.data >= other.data
    }
}

impl<T: Ord> Ord for Inner<T> {
    fn cmp(&self, other: &Inner<T>) -> Ordering {
        self.data.cmp(&other.data)
    }
}

impl<T: Eq> Eq for Inner<T> {}

impl<T: Hash> Hash for Inner<T> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.data.hash(state)
    }
}