atomex 0.1.1

Atomics extensions in 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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Fetch and apply operations to the current value, returning the previous
//! value.
use core::sync::atomic::Ordering;

/// Bitwise "and" with the current value.
pub trait And {
    /// The underlying primitive value type
    type Value;

    /// Bitwise "and" with the current value.
    ///
    /// Performs a bitwise "and" operation on the current value and the argument
    /// `val`, and sets the new value to the result.
    ///
    /// Returns the previous value.
    fn fetch_and(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}

/// Bitwise "nand" with the current value.
pub trait Nand {
    /// The underlying primitive value type
    type Value;

    /// Bitwise "nand" with the current value.
    ///
    /// Performs a bitwise "nand" operation on the current value and the
    /// argument `val`, and sets the new value to the result.
    ///
    /// Returns the previous value.
    fn fetch_nand(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}

/// Bitwise "or" with the current value.
pub trait Or {
    /// The underlying primitive value type
    type Value;

    /// Bitwise "or" with the current value.
    ///
    /// Performs a bitwise "or" operation on the current value and the argument
    /// `val`, and sets the new value to the result.
    ///
    /// Returns the previous value.
    fn fetch_or(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}

/// Bitwise "xor" with the current value.
pub trait Xor {
    /// The underlying primitive value type
    type Value;

    /// Bitwise "xor" with the current value.
    ///
    /// Performs a bitwise "xor" operation on the current value and the argument
    /// `val`, and sets the new value to the result.
    ///
    /// Returns the previous value.
    fn fetch_xor(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}

/// Adds to the current value, returning the previous value.
pub trait Add {
    /// The underlying primitive value type
    type Value;

    /// Adds to the current value, returning the previous value.
    ///
    /// This operation wraps around on overflow.
    fn fetch_add(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}

/// Subtracts from the current value, returning the previous value.
pub trait Sub {
    /// The underlying primitive value type
    type Value;

    /// Subtracts from the current value, returning the previous value.
    ///
    /// This operation wraps around on overflow.
    fn fetch_sub(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}

/// Fetches the value, and applies a function to it that returns an optional new
/// value.
pub trait Update {
    /// The underlying primitive value type
    type Value;

    /// Fetches the value, and applies a function to it that returns an optional
    /// new value.
    ///
    /// Returns a `Result` of `Ok(previous_value)` if the function returned
    /// `Some(_)`, else `Err(previous_value)`.
    fn fetch_update<F>(
        &self,
        fetch_order: Ordering,
        set_order: Ordering,
        f: F,
    ) -> Result<Self::Value, Self::Value>
    where
        F: FnMut(Self::Value) -> Option<Self::Value>;
}

/// Maximum with the current value.
pub trait Max {
    /// The underlying primitive value type
    type Value;

    /// Maximum with the current value.
    ///
    /// Finds the maximum of the current value and the argument `val`, and sets
    /// the new value to the result.
    ///
    /// Returns the previous value.
    fn fetch_max(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}

/// Minimum with the current value.
pub trait Min {
    /// The underlying primitive value type
    type Value;

    /// Minimum with the current value.
    ///
    /// Finds the minimum of the current value and the argument `val`, and sets
    /// the new value to the result.
    ///
    /// Returns the previous value.
    fn fetch_min(
        &self,
        val: Self::Value,
        order: Ordering,
    ) -> Self::Value;
}